smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-12 09:36:33 +01:00
Code Issues Projects Releases Wiki Activity

remove sigc 2.0.18, again. Come on baby...

Browse source 
git-svn-id: svn://localhost/ardour2/branches/3.0@3436 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Doug McLain 2008-06-02 21:48:31 +00:00
parent 449aab3c46
commit 176835be8d
72 changed files with 0 additions and 34477 deletions
Download patch file Download diff file Expand all files Collapse all files

19
libs/sigc++2/.cvsignore
View file

@ -1,19 +0,0 @@
Makefile
Makefile.in
aclocal.m4
autom4te.cache
config.guess
config.log
config.status
config.sub
depcomp
install-sh
libsigc++-2.0.spec
libtool
ltmain.sh
missing
sigc++-2.0.pc
stamp-h1
configure
sigc++config.h
*.dylib

8
libs/sigc++2/AUTHORS
View file

@ -1,8 +0,0 @@
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)

515
libs/sigc++2/COPYING
View file

@ -1,515 +0,0 @@
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.
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!

1249
libs/sigc++2/ChangeLog
View file

File diff suppressed because it is too large Load diff

229
libs/sigc++2/INSTALL
View file

@ -1,229 +0,0 @@
Copyright 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software
Foundation, Inc.
This file is free documentation; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, and a
file `config.log' containing compiler output (useful mainly for
debugging `configure').
It can also use an optional file (typically called `config.cache'
and enabled with `--cache-file=config.cache' or simply `-C') that saves
the results of its tests to speed up reconfiguring. (Caching is
disabled by default to prevent problems with accidental use of stale
cache files.)
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If you are using the cache, and at
some point `config.cache' contains results you don't want to keep, you
may remove or edit it.
The file `configure.ac' (or `configure.in') is used to create
`configure' by a program called `autoconf'. You only need
`configure.ac' if you want to change it or regenerate `configure' using
a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes awhile. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Optionally, type `make check' to run any self-tests that come with
the package.
4. Type `make install' to install the programs and any data files and
documentation.
5. You can remove the program binaries and object files from the
source code directory by typing `make clean'. To also remove the
files that `configure' created (so you can compile the package for
a different kind of computer), type `make distclean'. There is
also a `make maintainer-clean' target, but that is intended mainly
for the package's developers. If you use it, you may have to get
all sorts of other programs in order to regenerate files that came
with the distribution.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. Run `./configure --help'
for details on some of the pertinent environment variables.
You can give `configure' initial values for configuration parameters
by setting variables in the command line or in the environment. Here
is an example:
./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
*Note Defining Variables::, for more details.
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not support the `VPATH'
variable, you have to compile the package for one architecture at a
time in the source code directory. After you have installed the
package for one architecture, use `make distclean' before reconfiguring
for another architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
In addition, if you use an unusual directory layout you can give
options like `--bindir=PATH' to specify different values for particular
kinds of files. Run `configure --help' for a list of the directories
you can set and what kinds of files go in them.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' cannot figure out
automatically, but needs to determine by the type of machine the package
will run on. Usually, assuming the package is built to be run on the
_same_ architectures, `configure' can figure that out, but if it prints
a message saying it cannot guess the machine type, give it the
`--build=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name which has the form:
CPU-COMPANY-SYSTEM
where SYSTEM can have one of these forms:
OS KERNEL-OS
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the machine type.
If you are _building_ compiler tools for cross-compiling, you should
use the `--target=TYPE' option to select the type of system they will
produce code for.
If you want to _use_ a cross compiler, that generates code for a
platform different from the build platform, you should specify the
"host" platform (i.e., that on which the generated programs will
eventually be run) with `--host=TYPE'.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Defining Variables
==================
Variables not defined in a site shell script can be set in the
environment passed to `configure'. However, some packages may run
configure again during the build, and the customized values of these
variables may be lost. In order to avoid this problem, you should set
them in the `configure' command line, using `VAR=value'. For example:
./configure CC=/usr/local2/bin/gcc
will cause the specified gcc to be used as the C compiler (unless it is
overridden in the site shell script).
`configure' Invocation
======================
`configure' recognizes the following options to control how it
operates.
`--help'
`-h'
Print a summary of the options to `configure', and exit.
`--version'
`-V'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`--cache-file=FILE'
Enable the cache: use and save the results of the tests in FILE,
traditionally `config.cache'. FILE defaults to `/dev/null' to
disable caching.
`--config-cache'
`-C'
Alias for `--cache-file=config.cache'.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made. To
suppress all normal output, redirect it to `/dev/null' (any error
messages will still be shown).
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`configure' also accepts some other, not widely useful, options. Run
`configure --help' for more details.

30
libs/sigc++2/Makefile.am
View file

@ -1,30 +0,0 @@
# it includes all the autostuff automatically, you just name the
# other stuff here
EXTRA_DIST = autogen.sh sigc++config.h.in libsigc++-2.0.spec.in
# ACLOCAL_FLAGS = -I scripts
SUBDIRS = sigc++
DIST_SUBDIRS = $(SUBDIRS)
sigc_configdir = $(libdir)/sigc++-2.0/include
sigc_config_DATA = sigc++config.h
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = sigc++-2.0.pc
all-local:
@echo "*** Everything completed ***"
dist-hook:
@echo; echo; \
echo "**********************************************************"; \
echo "* IMPORTANT NOTICE: *"; \
echo "* *"; \
echo "* Be sure you have done a complete build before running *"; \
echo "* 'make dist' or 'make distcheck', because otherwise *"; \
echo "* the tarball will _not_ contain the dependency rules *"; \
echo "* generated by the compiler. *"; \
echo "**********************************************************"; \
echo; echo \
cp libsigc++-2.0.spec $(distdir)

232
libs/sigc++2/NEWS
View file

@ -1,232 +0,0 @@
*** libsigc++ 2.0:
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.
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 with a simpler and more powerful API.
This version of libsigc++ needs GNU g++ 3.2 or higher to compile.
*** ChangeLog summary:
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".

72
libs/sigc++2/README
View file

@ -1,72 +0,0 @@
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 about the major release 2.0 is available on the
libsigc++ project home page: http://libsigc.sourceforge.net/
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:
Maintainer: mailto: mschulze@cvs.gnome.org
Maillist: mailto: libsigc-list@gnome.org
Homepage: http://libsigc.sourceforge.net
Online reference documentation: http://libsigc.sourceforge.net/libsigc2/docs/
Ftp: http://ftp.gnome.org/pub/GNOME/sources/libsigc++/2.0/
CVS:
Overview of the distribution:
docs/ documentation on the signal system
docs/reference/ reference documentation
examples/ examples of various signal functions
sigc++/ source for library
sigc++/macros/ .m4 files used to auto-generate source files
sigc++/functors/ source for library (various functors)
sigc++/functors/macros/ .m4 files used to auto-generate source files
sigc++/adaptors/ source for library (various adaptors)
sigc++/adaptors/macros/ .m4 files used to auto-generate source files
sigc++/adpators/lambda/ source for library (lambda library)
sigc++/adpators/lambda/macros/ .m4 files used to auto-generate source files
scripts/ automake junk
tests/ programs testing and verifying proper behaviour
MSVC_Net2003/ project files for building the library with MSVC .NET 2003
Compatibility:
Compatible compilers must supports the following recent c++ techniques:
* Partial template (function) specialization.
* Explicit template (member) function instantiation.
* Treat void return as normal return.
This release has only been tested with gcc-3.3. It should at least also compile with:
* gcc >= 3.2
* cygwin (gcc >= 3.2)
* mingw32
* Microsoft Visual Studio .Net 2003
* Sun Forte C++ compiler >= 5.5
* Compaq C++ compiler
* Intel compiler
Please report any troubles you encounter with these compilers!
You are also invited to try a compiler that is not listed above.

41
libs/sigc++2/SConscript
View file

@ -1,41 +0,0 @@
# -*- python -*-
import os
import os.path
import glob
sigc2_files = glob.glob('sigc++/*.cc') + glob.glob('sigc++/functors/*.cc') + glob.glob('sigc++/adaptors/lambda/*.cc')
Import('env install_prefix')
sigc2 = env.Copy()
libsigc2 = sigc2.SharedLibrary('sigc++2', sigc2_files)
if os.access ('autogen.sh', os.F_OK) :
sigc2_configure_script = sigc2.Command ('configure', 'configure.ac', 'cd libs/sigc++2 && ./autogen.sh && cd -', ENV=os.environ)
sigc2_config_h = sigc2.Command('sigc++config.h', [sigc2_configure_script, 'sigc++config.h.in'], 'cd libs/sigc++2 && ./configure && cd -', ENV=os.environ)
else :
sigc2_config_h = sigc2.Command('sigc++config.h', ['configure', 'sigc++config.h.in'], 'cd libs/sigc++2 && ./configure && cd -', ENV=os.environ)
Default([sigc2_config_h,libsigc2])
env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour3'), libsigc2))
env.Alias('tarball', env.Distribute (env['DISTTREE'],
[ 'NEWS', 'README', 'AUTHORS', 'ChangeLog',
'configure', 'configure.ac', 'Makefile.am', 'SConscript',
'sigc++/Makefile.in',
'sigc++config.h',
'sigc++config.h.in',
'sigc++-2.0.pc.in',
'libsigc++-2.0.spec.in',
'install-sh',
'Makefile.in',
'scripts',
'missing',
] + sigc2_files +
glob.glob('sigc++/*.h') +
glob.glob('sigc++/functors/*.h') + glob.glob('sigc++/adaptors/lambda/*.h') +
glob.glob('sigc++/adaptors/*.h')
))

66
libs/sigc++2/TODO
View file

@ -1,66 +0,0 @@
Compatibility:
- Fix compilation for SUN FORTE C++ 5.5.
Configure checks and Makefile issues:
- When you use a single Makefile.am for
several directories (in sigc++2, all under sigc++/ is ruled by a
single Makefile.am with the new build system), you have a problem when
you do a build where $(srcdir) != $(builddir), since in the build-tree
the necessary subdirectories are not created. So I have to find a
place where to create this directories, in case they do not exist.
This is only an issue for clean CVS checkouts, however (Andy)
sigc++-1.2 compatibility:
- Verify completeness.
documentation:
- Improve documentation: Make groups (see index.html). Exclude stuff to make
the html output readable.
- Add documentation for adaptors and accumulators.
basic functionality:
- I don't understand what is meant by "stl-pointer-like functions" (Martin):
slot should have the full set of stl pointer like functions. (Karl Nelson)
lambda functionality (I don't understand this (Martin)):
- Add support for _R to force references down into
the stack frame of lambda. Ie.
A a;
(_1+_2)(1,a); // fail if no "operator int() const"
- Call groups in lambda. (Huh, that appears to be in group?)
Old TODO's that should be almost finished (Martin):
- Fine-tooth comb the code looking for missing operator =() function
and missing copy constructors.
- Improve and expand the test suite. There are a lot of combinations which
should be valid but haven't been tested which are likely to result in
wierd compiler errors if something wasn't done consistantly.
Old TODO's that should be finished (Martin):
- Improve signal#, it currently is just barely functional.
- Add iterator support and stl like functionality to signal.
- Add blocking capablity to slot.
- Deinline/move to .cc where possible to move functions into the
library to reduce resulting binary size.

39
libs/sigc++2/autogen.sh
View file

@ -1,39 +0,0 @@
#! /bin/sh
# check all tools first
if /usr/bin/which libtoolize >/dev/null 2>&1 ; then
:
else
echo "You do not have libtool installed, which is very sadly required to build part of Ardour"
exit 1
fi
if /usr/bin/which automake >/dev/null 2>&1 ; then
:
else
echo "You do not have automake installed, which is very sadly required to build part of Ardour"
exit 1
fi
if /usr/bin/which autoconf >/dev/null 2>&1 ; then
:
else
echo "You do not have autoconf installed, which is very sadly required to build part of Ardour"
exit 1
fi
srcdir=`dirname $0`
test -z "$srcdir" && srcdir=.
#echo "Adding libtools."
#libtoolize --automake --copy --force
echo "Building macros."
aclocal -I "$srcdir/scripts" $ACLOCAL_FLAGS
echo "Building makefiles."
automake --add-missing --copy
echo "Building configure."
autoconf
rm -f config.cache

64
libs/sigc++2/configure.ac
View file

@ -1,64 +0,0 @@
dnl Configure.in
dnl
dnl Source for generating compiler independent libraries.
dnl
dnl INIT is required name a file which is unique to the package
dnl just to prevent someone from copying the configure to the wrong package.
AC_INIT(sigc++)
dnl This version stuff is just for the packaging section of the tool.
dnl thus make format_package-0.0.1.tar.gz
FP_MAJOR_VERSION=2
FP_MINOR_VERSION=0
FP_MICRO_VERSION=6
FP_VERSION=$FP_MAJOR_VERSION.$FP_MINOR_VERSION.$FP_MICRO_VERSION
dnl For automake.
VERSION=$FP_VERSION
PACKAGE=libsigc++
dnl Initialize automake stuff
AM_INIT_AUTOMAKE($PACKAGE, $VERSION)
dnl Specify a configuration file:
AC_CONFIG_HEADER(sigc++config.h)
dnl disable autoheader
AUTOHEADER=':'
dnl Maintainer support (autodependencies and packaging)
AM_MAINTAINER_MODE
dnl Using C compiler
AC_PROG_CC
AC_PROG_CPP
dnl Using libtool
AC_CONFIG_MACRO_DIR(scripts)
dnl LT_INIT
dnl AM_PROG_LIBTOOL
dnl Using C++ compiler
AC_PROG_CXX
AC_LANG_CPLUSPLUS
SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD()
if test "X$config_error" = "Xyes" ; then
AC_ERROR(
[One or more of the required compiler features is missing.
If you believe this is in error, please consult the config.log file
for further details.
])
fi
# Generate output
AC_OUTPUT([
Makefile
sigc++-2.0.pc
sigc++/Makefile
libsigc++-2.0.spec
])

91
libs/sigc++2/libsigc++-2.0.spec.in
View file

@ -1,91 +0,0 @@
Summary: The Typesafe Signal Framework for C++
Name: @PACKAGE@
Version: @VERSION@
Release: 1
License: LGPL
Group: System Environment/Libraries
Packager: Eric Bourque <ericb@computer.org>
URL: http://libsigc.sourceforge.net/
Source0: http://ftp.gnome.org/pub/GNOME/sources/libsigc++/2.0/%{name}-%{version}.tar.bz2
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root
%description
This library implements a full callback system for use in widget
libraries, abstract interfaces, and general programming. Originally
part of the Gtk-- widget set, %name is now a seperate library to
provide for more general use. It is the most complete library of its
kind with the ablity to connect an abstract callback to a class
method, function, or function object. It contains adaptor classes for
connection of dissimilar callbacks and has an ease of use unmatched by
other C++ callback libraries.
Package GTK-- (gtkmm), which is a C++ binding to the GTK+ library,
starting with version 1.1.2, uses %name.
Due to C++ ABI changes, this will only work with the gcc version which
the distribution was supplied with. If you got your rpm from any
previous version, please rebuild from spec!
%package devel
Summary: Development tools for the Typesafe Signal Framework for C++
Group: Development/Libraries
Requires: %name = %version
%description devel
The %name-devel package contains the static libraries and header files
needed for development with %name.
%package examples
Summary: Examples and tests for the Typesafe Signal Framework for C++
Group: Development/Libraries
Requires: %name-devel = %version
%description examples
The %name-devel package contains source code of
example and test programs for %name.
%prep
%setup -q
%build
./configure --prefix=/usr
make
%install
rm -rf $RPM_BUILD_ROOT
make DESTDIR=$RPM_BUILD_ROOT install
mkdir -p -m 755 $RPM_BUILD_ROOT/%{_libdir}/sigc++-2.0
cp -a examples tests $RPM_BUILD_ROOT/%{_libdir}/sigc++-2.0
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root,-)
%{_libdir}/libsigc*.so*
%doc /usr/share/doc/libsigc-2.0
%files devel
/usr/include/sigc++-2.0
%{_libdir}/pkgconfig/*
%{_libdir}/libsigc*.a
%{_libdir}/libsigc*.la
%dir %{_libdir}/sigc++-2.0
%dir %{_libdir}/sigc++-2.0/include
%{_libdir}/sigc++-2.0/include/sigc++config.h
%files examples
%{_libdir}/sigc++-2.0/examples
%{_libdir}/sigc++-2.0/tests
%changelog
* Tue Jun 29 2004 Eric Bourque <ericb@computer.org> - 2.0-1
- Initial build.

94
libs/sigc++2/scripts/cxx.m4
View file

@ -1,94 +0,0 @@
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_TRY_COMPILE(
[
#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.])
AC_MSG_RESULT([$sigcm_cxx_gcc_template_specialization_operator_overload])
],[
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_TRY_COMPILE(
[
#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.])
AC_MSG_RESULT([$sigcm_cxx_msvc_template_specialization_operator_overload])
],[
sigcm_cxx_msvc_template_specialization_operator_overload=no
AC_MSG_RESULT([$sigcm_cxx_msvc_template_specialization_operator_overload])
])
])

5767
libs/sigc++2/scripts/libtool.m4 vendored
View file

File diff suppressed because it is too large Load diff

358
libs/sigc++2/scripts/ltoptions.m4 vendored
View file

@ -1,358 +0,0 @@
# Helper functions for option handling. -*- Autoconf -*-
# Written by Gary V. Vaughan <gary@gnu.org>
# Copyright (C) 2004 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
# 02111-1307, USA.
# serial 1
# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
# _LT_MANGLE_OPTION(NAME)
# -----------------------
m4_define([_LT_MANGLE_OPTION],
[[_LT_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
# _LT_SET_OPTION(NAME)
# ------------------------------
# Set option NAME. Other NAMEs are saved as a flag.
m4_define([_LT_SET_OPTION], [m4_define(_LT_MANGLE_OPTION([$1]))])
# _LT_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
# -------------------------------------------
# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
m4_define([_LT_IF_OPTION],
[m4_ifdef(_LT_MANGLE_OPTION([$1]), [$2], [$3])])
# _LT_UNLESS_OPTIONS(OPTIONS, IF-NOT-SET)
# ---------------------------------------
# Execute IF-NOT-SET if all OPTIONS are not set.
m4_define([_LT_UNLESS_OPTIONS],
[AC_FOREACH([_LT_Option], [$1],
[m4_ifdef(_LT_MANGLE_OPTION(_LT_Option),
[m4_define([$0_found])])])[]dnl
m4_ifdef([$0_found], [m4_undefine([$0_found])], [$2
])[]dnl
])
# _LT_SET_OPTIONS(OPTIONS)
# ------------------------
# OPTIONS is a space-separated list of Automake options.
# If any OPTION has a handler macro declared with LT_OPTION_DEFINE,
# despatch to that macro; otherwise complain about the unknown option
# and exit.
m4_define([_LT_SET_OPTIONS],
[AC_FOREACH([_LT_Option], [$1],
[_LT_SET_OPTION(_LT_Option)
m4_ifdef(_LT_MANGLE_DEFUN(_LT_Option),
_LT_MANGLE_DEFUN(_LT_Option),
[m4_fatal([Unknown option `]_LT_Option[' to LT][_INIT_LIBTOOL])])
])dnl
dnl
dnl Simply set some default values (i.e off) if boolean options were not
dnl specified:
_LT_UNLESS_OPTIONS([dlopen], enable_dlopen=no)
_LT_UNLESS_OPTIONS([win32-dll], enable_win32_dll=no)
dnl
dnl If no reference was made to various pairs of opposing options, then
dnl we run the default mode handler for the pair. For example, if neither
dnl `shared' nor `disable-shared' was passed, we enable building of shared
dnl archives by default:
_LT_UNLESS_OPTIONS([shared disable-shared], [_LT_ENABLE_SHARED])
_LT_UNLESS_OPTIONS([static disable-static], [_LT_ENABLE_STATIC])
_LT_UNLESS_OPTIONS([pic-only no-pic], [_LT_WITH_PIC])
_LT_UNLESS_OPTIONS([fast-install disable-fast-install],
[_LT_ENABLE_FAST_INSTALL])
])# _LT_SET_OPTIONS
## ----------------------------------------- ##
## Macros to handle LT_INIT_LIBTOOL options. ##
## ----------------------------------------- ##
m4_define([_LT_MANGLE_DEFUN],
[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1]), [[^A-Z0-9_]], [_])])
# LT_OPTION_DEFINE(NAME, CODE)
# ----------------------------
m4_define([LT_OPTION_DEFINE],
[m4_define(_LT_MANGLE_DEFUN([$1]), [$2])[]dnl
])# LT_OPTION_DEFINE
# dlopen
# ------
LT_OPTION_DEFINE([dlopen], [enable_dlopen=yes])
AU_DEFUN([AC_LIBTOOL_DLOPEN],
[_LT_SET_OPTION([dlopen])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `dlopen' option into LT_LIBTOOL_INIT's first parameter.])
])
# win32-dll
# ---------
# Declare package support for building win32 dll's.
LT_OPTION_DEFINE([win32-dll],
[enable_win32_dll=yes
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32*)
AC_CHECK_TOOL(AS, as, false)
AC_CHECK_TOOL(DLLTOOL, dlltool, false)
AC_CHECK_TOOL(OBJDUMP, objdump, false)
;;
esac
test -z "$AS" && AS=as
_LT_DECL([], [AS], [0], [Assembler program])dnl
test -z "$DLLTOOL" && DLLTOOL=dlltool
_LT_DECL([], [DLLTOOL], [0], [DLL creation program])dnl
test -z "$OBJDUMP" && OBJDUMP=objdump
_LT_DECL([], [OBJDUMP], [0], [Object dumper program])dnl
])# win32-dll
AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
[_LT_SET_OPTION([win32-dll])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `win32-dll' option into LT_LIBTOOL_INIT's first parameter.])
])
# _LT_ENABLE_SHARED([DEFAULT])
# ----------------------------
# implement the --enable-shared flag, and supports the `shared' and
# `disable-shared' LT_INIT_LIBTOOL options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_SHARED],
[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([shared],
[AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
[p=${PACKAGE-default}
case $enableval in
yes) enable_shared=yes ;;
no) enable_shared=no ;;
*)
enable_shared=no
# Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
for pkg in $enableval; do
IFS="$lt_save_ifs"
if test "X$pkg" = "X$p"; then
enable_shared=yes
fi
done
IFS="$lt_save_ifs"
;;
esac],
[enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
_LT_DECL([build_libtool_libs], [enable_shared], [0],
[Whether or not to build shared libraries])
])# _LT_ENABLE_SHARED
LT_OPTION_DEFINE([shared], [_LT_ENABLE_SHARED([yes])])
LT_OPTION_DEFINE([disable-shared], [_LT_ENABLE_SHARED([no])])
# Old names:
AU_DEFUN([AC_ENABLE_SHARED],
[_LT_SET_OPTION([shared])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `shared' option into LT_LIBTOOL_INIT's first parameter.])
])
AU_DEFUN([AM_ENABLE_SHARED],
[_LT_SET_OPTION([shared])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `shared' option into LT_LIBTOOL_INIT's first parameter.])
])
AU_DEFUN([AC_DISABLE_SHARED],
[_LT_SET_OPTION([disable-shared])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-shared' option into LT_LIBTOOL_INIT's first parameter.])
])
AU_DEFUN([AM_DISABLE_SHARED],
[_LT_SET_OPTION([disable-shared])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-shared' option into LT_LIBTOOL_INIT's first parameter.])
])
# _LT_ENABLE_STATIC([DEFAULT])
# ----------------------------
# implement the --enable-static flag, and support the `static' and
# `disable-static' LT_INIT_LIBTOOL options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_STATIC],
[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([static],
[AC_HELP_STRING([--enable-static@<:@=PKGS@:>@],
[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
[p=${PACKAGE-default}
case $enableval in
yes) enable_static=yes ;;
no) enable_static=no ;;
*)
enable_static=no
# Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
for pkg in $enableval; do
IFS="$lt_save_ifs"
if test "X$pkg" = "X$p"; then
enable_static=yes
fi
done
IFS="$lt_save_ifs"
;;
esac],
[enable_static=]_LT_ENABLE_STATIC_DEFAULT)
_LT_DECL([build_old_libs], [enable_static], [0],
[Whether or not to build static libraries])
])# _LT_ENABLE_STATIC
LT_OPTION_DEFINE([static], [_LT_ENABLE_STATIC([yes])])
LT_OPTION_DEFINE([disable-static], [_LT_ENABLE_STATIC([no])])
# Old names:
AU_DEFUN([AC_ENABLE_STATIC],
[_LT_SET_OPTION([static])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `static' option into LT_LIBTOOL_INIT's first parameter.])
])
AU_DEFUN([AM_ENABLE_STATIC],
[_LT_SET_OPTION([static])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `static' option into LT_LIBTOOL_INIT's first parameter.])
])
AU_DEFUN([AC_DISABLE_STATIC],
[_LT_SET_OPTION([disable-static])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-static' option into LT_LIBTOOL_INIT's first parameter.])
])
AU_DEFUN([AM_DISABLE_STATIC],
[_LT_SET_OPTION([disable-static])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-static' option into LT_LIBTOOL_INIT's first parameter.])
])
# _LT_ENABLE_FAST_INSTALL([DEFAULT])
# ----------------------------------
# implement the --enable-fast-install flag, and support the `fast-install'
# and `disable-fast-install' LT_INIT_LIBTOOL options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_FAST_INSTALL],
[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([fast-install],
[AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
[optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
[p=${PACKAGE-default}
case $enableval in
yes) enable_fast_install=yes ;;
no) enable_fast_install=no ;;
*)
enable_fast_install=no
# Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
for pkg in $enableval; do
IFS="$lt_save_ifs"
if test "X$pkg" = "X$p"; then
enable_fast_install=yes
fi
done
IFS="$lt_save_ifs"
;;
esac],
[enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
_LT_DECL([fast_install], [enable_fast_install], [0],
[Whether or not to optimize for fast installation])dnl
])# _LT_ENABLE_FAST_INSTALL
LT_OPTION_DEFINE([fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
LT_OPTION_DEFINE([disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
# Old names:
AU_DEFUN([AC_ENABLE_FAST_INSTALL],
[_LT_SET_OPTION([fast-install])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `fast-install' option into LT_LIBTOOL_INIT's first parameter.])
])
AU_DEFUN([AC_DISABLE_FAST_INSTALL],
[_LT_SET_OPTION([disable-fast-install])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-fast-install' option into LT_LIBTOOL_INIT's first parameter.])
])
# _LT_WITH_PIC([MODE])
# --------------------
# implement the --with-pic flag, and support the `pic-only' and `no-pic'
# LT_INIT_LIBTOOL options.
# MODE is either `yes' or `no'. If omitted, it defaults to `both'.
m4_define([_LT_WITH_PIC],
[AC_ARG_WITH([pic],
[AC_HELP_STRING([--with-pic],
[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
[pic_mode="$withval"],
[pic_mode=default])
test -z "$pic_mode" && pic_mode=m4_if($#, 1, $1, default)
_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
])# _LT_WITH_PIC
LT_OPTION_DEFINE([pic-only], [_LT_WITH_PIC([yes])])
LT_OPTION_DEFINE([no-pic], [_LT_WITH_PIC([no])])
# Old name:
AU_DEFUN([AC_LIBTOOL_PIC_MODE],
[_LT_SET_OPTION([pic-only])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `pic-only' option into LT_LIBTOOL_INIT's first parameter.])
])

115
libs/sigc++2/scripts/ltsugar.m4 vendored
View file

@ -1,115 +0,0 @@
# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*-
#
# Copyright (C) 2004 Free Software Foundation, Inc.
# Written by Gary V. Vaughan.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# serial 1
# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
# lt_join(SEP, ARG1, [ARG2...])
# -----------------------------
# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
# associated separator.
m4_define([lt_join],
[m4_case([$#],
[0], [m4_fatal([$0: too few arguments: $#])],
[1], [],
[2], [[$2]],
[m4_ifval([$2],
[m4_ifval([$3],
[[$2][$1][]$0([$1], m4_shiftn(2, $@))],
[m4_if([$#], [3],
[$2],
[$0([$1], [$2], m4_shiftn(3, $@))])])],
[$0([$1], m4_shiftn(2, $@))])])[]dnl
])
# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
# ----------------------------------------------------------
# Produce a SEP delimited list of all paired combinations of elements of
# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list
# has the form PREFIXmINFIXSUFFIXn.
m4_define([lt_combine],
[m4_if([$2], [[]], [],
[lt_join(m4_quote(m4_default([$1], [, ])),
_$0([$1], m4_car($2)[$3], m4_shiftn(3, $@)),
$0([$1], m4_cdr($2), m4_shiftn(2, $@)))])])
m4_define([_lt_combine],
[m4_if([$3], [], [],
[lt_join(m4_quote(m4_default([$1], [, ])),
[$2$3],
$0([$1], [$2], m4_shiftn(3, $@)))])[]dnl
])
# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
# -----------------------------------------------------------------------
# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
m4_define([lt_if_append_uniq],
[m4_ifdef([$1],
[m4_bmatch($3[]m4_defn([$1])$3, $3[]m4_re_escape([$2])$3,
[$5],
[m4_append([$1], [$2], [$3])$4])],
[m4_append([$1], [$2], [$3])$4])])
# lt_dict_add(DICT, KEY, VALUE)
# -----------------------------
m4_define([lt_dict_add],
[m4_define([$1($2)], [$4])])
# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
# --------------------------------------------
m4_define([lt_dict_add_subkey],
[m4_define([$1($2:$3)], [$4])])
# lt_dict_fetch(DICT, KEY, [SUBKEY])
# ----------------------------------
m4_define([lt_dict_fetch],
[m4_ifval([$3],
m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
# -----------------------------------------------------------------
m4_define([lt_if_dict_fetch],
[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
[$5],
[$6])])
# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
# ------------------------------------------------------------
m4_define([lt_dict_filter],
[m4_if([$5], [], [],
[lt_join(m4_quote(m4_default([$4], [[, ]])),
m4_quote(lt_if_dict_fetch([$1], [$5], [$2], [$3], [$5])),
m4_quote($0([$1], [$2], [$3], [$4], m4_shiftn(5, $@))))])dnl
])

15
libs/sigc++2/scripts/ltversion.m4 vendored
View file

@ -1,15 +0,0 @@
# ltversion.m4 -- version numbers -*- Autoconf -*-
# Generated from ltversion.in; do not edit by hand.
# serial 1467
# This file is part of GNU Libtool
m4_define([LT_PACKAGE_VERSION], [])
m4_define([LT_PACKAGE_REVISION], [1.1467])
AC_DEFUN([LTVERSION_VERSION],
[macro_version=''
macro_revision='1.1467'
_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
_LT_DECL(, macro_revision, 0)
])

10
libs/sigc++2/sigc++-2.0.pc.in
View file

@ -1,10 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: libsigc++ 2
Description: Typesafe signal and callback system for C++
Version: @VERSION@
Libs: -L${libdir} -lsigc-2.0
Cflags: -I${includedir}/sigc++-2.0 -I${libdir}/sigc++-2.0/include

4
libs/sigc++2/sigc++/.cvsignore
View file

@ -1,4 +0,0 @@
Makefile
Makefile.in
.deps
*.os

97
libs/sigc++2/sigc++/Makefile.am
View file

@ -1,97 +0,0 @@
# Base (./)
base_m4 = template.macros.m4 signal.h.m4 slot.h.m4 method_slot.h.m4 \
object_slot.h.m4 class_slot.h.m4 hide.h.m4 retype.h.m4
base_built_cc =
base_built_h = signal.h slot.h method_slot.h \
object_slot.h class_slot.h hide.h retype.h
signal.cc : signal.h signal_base.h functors/slot.h functors/slot_base.h functors/mem_fun.h functors/functor_trait.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
functors/slot.cc : functors/slot.h functors/slot_base.h functors/functor_trait.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
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
# Lambda (adaptors/lambda)
lambda_m4 = base.h.m4 select.h.m4 operator.h.m4 group.h.m4 lambda.cc.m4
lambda_built_cc = lambda.cc
lambda_built_h = base.h select.h operator.h group.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
# Subdirectories needed also in the build dir
build_subdirs = functors adaptors adaptors/lambda
# 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/%)
EXTRA_DIST = $(sigc_m4) $(sigc_built_h) $(sigc_built_cc)
# install the headers
library_includedir = $(includedir)/sigc++-2.0/sigc++
nobase_library_include_HEADERS = $(sigc_m4) $(sigc_built_h) \
sigc++.h connection.h trackable.h reference_wrapper.h type_traits.h visit_each.h \
object.h retype_return.h bind.h bind_return.h compatibility.h signal_base.h \
functors/functors.h \
functors/slot_base.h \
adaptors/adaptors.h \
adaptors/lambda/lambda.h
# build the library
#lib_LTLIBRARIES = libsigc-2.0.la
#libsigc_2_0_la_SOURCES = signal.cc signal_base.cc trackable.cc connection.cc \
functors/slot.cc functors/slot_base.cc \
adaptors/lambda/lambda.cc
#libsigc_2_0_la_LDFLAGS =
BUILT_SOURCES = $(sigc_built_h) $(sigc_built_cc)
CLEANFILES = build-subdirs-stamp
# Remove the generated sources during maintainer-clean:
MAINTAINERCLEANFILES = $(built_sources)
M4_DIR = $(top_srcdir)/sigc++/macros
# Rules to generate .h and .cc from .h.m4 and .cc.m4:
%.h: macros/%.h.m4 $(M4_DIR)/template.macros.m4
$(M4) $(M4_INCLUDES) $(DEFINES) -I $(M4_DIR) -I macros $< > $@
%.cc: macros/%.cc.m4 $(M4_DIR)/template.macros.m4
$(M4) $(M4_INCLUDES) $(DEFINES) -I $(M4_DIR) -I macros $< > $@
# This would be a necessary target for VPATH builds from a clean CVS checkout,
# but I'm not sure where to invoke it... [rotty]
build-subdirs-stamp:
for dir in $(build_subdirs); do \
test -d $$dir || mkdir $$dir; \
done
touch build-subdirs-stamp
# Remove current directory from DEFAULT_INCLUDES because signal.h has
# the same name as a standard header:
DEFAULT_INCLUDES =
AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir)

1
libs/sigc++2/sigc++/adaptors/.cvsignore
View file

@ -1 +0,0 @@
*.os

362
libs/sigc++2/sigc++/adaptors/adaptor_trait.h
View file

@ -1,362 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_ADAPTORS_MACROS_ADAPTOR_TRAITHM4_
#define _SIGC_ADAPTORS_MACROS_ADAPTOR_TRAITHM4_
#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
template <class T_functor> struct adapts;
/** @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() and group().
*
* You can easily derive your own adaptor type from sigc::adapts.
*/
/** Converts an arbitrary functor into an adaptor type.
* All adaptor tyes in libsigc++ are unnumbered and 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
{
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 sigc::deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type; };
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_(); }
/** 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_action, class T_functor>
void visit_each(const T_action& _A_action,
const adaptor_functor<T_functor>& _A_target)
{
visit_each(_A_action, _A_target.functor_);
}
/** 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
*/
template <class T_functor, bool I_isadaptor = is_base_and_derived<adaptor_base, T_functor>::value> struct adaptor_trait;
/** 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;
};
/** Base type for adaptors.
* 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 @e T_functor unless @e T_functor
* inherits from sigc::adaptor_base.
*
* @par Example of a simple adaptor:
* @code
* template <T_functor>
* struct my_adpator : public sigc::adapts<T_functor>
* {
* template <class T_arg1=void, class T_arg2=void>
* struct deduce_result_type
* { typedef typename sigc::deduce_result_type<T_functor, T_arg1, T_arg2>::type 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, class T_arg2) const;
*
* explicit adaptor_functor(const T_functor& _A_functor) // Constructs a my_functor object that wraps the passed functor.
* : sigc::adapts<T_functor>(_A_functor) {}
*
* mutable T_functor functor_; // Functor that is invoked from operator()().
* };
* @endcode
*
* @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_MACROS_ADAPTOR_TRAITHM4_ */

32
libs/sigc++2/sigc++/adaptors/adaptors.h
View file

@ -1,32 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#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/lambda/lambda.h>
#endif /* _SIGC_ADAPTOR_HPP_ */

2262
libs/sigc++2/sigc++/adaptors/bind.h
View file

File diff suppressed because it is too large Load diff

204
libs/sigc++2/sigc++/adaptors/bind_return.h
View file

@ -1,204 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
#define _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
#include <sigc++/adaptors/adaptor_trait.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>
{
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; };
typedef T_return result_type;
/** Invokes the wrapped functor dropping its return value.
* @return The fixed return value.
*/
T_return operator()();
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 Argument to be passed on to the functor.)
* @return The fixed return value.
*/
template <class T_arg1>
inline T_return operator()(T_arg1 _A_a1)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); return ret_value_;
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
inline T_return sun_forte_workaround(T_arg1 _A_a1)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); return ret_value_;
}
#endif
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 Argument to be passed on to the functor.)
* @return The fixed return value.
*/
template <class T_arg1,class T_arg2>
inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_A_a1,_A_a2); return ret_value_;
}
#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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_A_a1,_A_a2); return ret_value_;
}
#endif
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 Argument to be passed on to the functor.)
* @return The fixed return value.
*/
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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_A_a1,_A_a2,_A_a3); return ret_value_;
}
#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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_A_a1,_A_a2,_A_a3); return ret_value_;
}
#endif
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 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 T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
}
#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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
}
#endif
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 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 T_return 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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
}
#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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
}
#endif
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 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 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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
}
#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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
}
#endif
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 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 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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
}
#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)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
}
#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(typename type_trait<T_functor>::take _A_functor, typename type_trait<T_return>::take _A_ret_value)
: adapts<T_functor>(_A_functor), ret_value_(_A_ret_value)
{}
/// The fixed return value.
T_return ret_value_; // public, so that visit_each() can access it
};
template <class T_return, class T_functor>
T_return bind_return_functor<T_return, T_functor>::operator()()
{ this->functor_(); return ret_value_; }
/** 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_action, class T_return, class T_functor>
void visit_each(const T_action& _A_action,
const bind_return_functor<T_return, T_functor>& _A_target)
{
visit_each(_A_action, _A_target.ret_value_);
visit_each(_A_action, _A_target.functor_);
}
/** 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<typename unwrap_reference<T_return>::type, T_functor>
bind_return(const T_functor& _A_functor, T_return _A_ret_value)
{ return bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>(_A_functor, _A_ret_value); }
} /* namespace sigc */
#endif /* _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_ */

294
libs/sigc++2/sigc++/adaptors/compose.h
View file

@ -1,294 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_ADAPTORS_MACROS_COMPOSEHM4_
#define _SIGC_ADAPTORS_MACROS_COMPOSEHM4_
#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 into
* sigc::signal::connect() directly.
*
* @par Example:
* @code
* sigc::signal<float,float,float> some_signal;
* some_signal.connect(sigc::compose(&square_root, &sum));
* @endcode
*
* For a more powerful version of this functionality see the lambda
* library adaptor sigc::group() which can bind, hide and reorder
* arguments arbitrarily. Although sigc::group() is more flexible,
* sigc::bind() provides a means of binding parameters when then total
* number of parameters called is variable.
*
* @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;
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_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
>::type type; };
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<typename sigc::deduce_result_type<T_getter, T_arg1>::type>
(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<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2>::type>
(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<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3>::type>
(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<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4>::type>
(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<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>
(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<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>
(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<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>
(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_getter1 Functor to invoke from operator()().
* @param _A_getter2 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)
{}
T_getter 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;
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_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
>::type result_type; };
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<typename sigc::deduce_result_type<T_getter1, T_arg1>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1>::type>
(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<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2>::type>
(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<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3>::type>
(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<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4>::type>
(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<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>
(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<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>
(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<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>
(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)
{}
T_getter1 get1_; // public, so that visit_each() can access it
T_getter2 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_()); }
/** 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_action, class T_setter, class T_getter>
void visit_each(const T_action& _A_action,
const compose1_functor<T_setter, T_getter>& _A_target)
{
visit_each(_A_action, _A_target.functor_);
visit_each(_A_action, _A_target.get_);
}
/** 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_action, class T_setter, class T_getter1, class T_getter2>
void visit_each(const T_action& _A_action,
const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
{
visit_each(_A_action, _A_target.functor_);
visit_each(_A_action, _A_target.get1_);
visit_each(_A_action, _A_target.get2_);
}
/** 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_MACROS_COMPOSEHM4_ */

121
libs/sigc++2/sigc++/adaptors/deduce_result_type.h
View file

@ -1,121 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
/*
*/
#ifndef _SIGC_ADAPTORS_MACROS_DEDUCE_RESULT_TYPEHM4_
#define _SIGC_ADAPTORS_MACROS_DEDUCE_RESULT_TYPEHM4_
#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_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,
bool I_derives_adaptor_base=is_base_and_derived<adaptor_base,T_functor>::value>
struct deduce_result_type
{ typedef typename functor_trait<T_functor>::result_type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 0 arguments.
*/
template <class T_functor>
struct deduce_result_type<T_functor, void,void,void,void,void,void,void, true>
{ typedef typename T_functor::template deduce_result_type<>::type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 1 arguments.
*/
template <class T_functor, class T_arg1>
struct deduce_result_type<T_functor, T_arg1, void,void,void,void,void,void, true>
{ typedef typename T_functor::template deduce_result_type<T_arg1>::type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 2 arguments.
*/
template <class T_functor, class T_arg1,class T_arg2>
struct deduce_result_type<T_functor, T_arg1,T_arg2, void,void,void,void,void, true>
{ typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2>::type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 3 arguments.
*/
template <class T_functor, class T_arg1,class T_arg2,class T_arg3>
struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3, void,void,void,void, true>
{ typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 4 arguments.
*/
template <class T_functor, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4, void,void,void, true>
{ typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 5 arguments.
*/
template <class T_functor, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, void,void, true>
{ typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 6 arguments.
*/
template <class T_functor, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, void, true>
{ typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type type; };
/** Deduce the return type of a functor.
* This is the template specialization of the sigc::deduce_result_type template
* for 7 arguments.
*/
template <class T_functor, 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<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, true>
{ typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type; };
} /* namespace sigc */
#endif /* _SIGC_ADAPTORS_MACROS_DEDUCE_RESULT_TYPEHM4_ */

319
libs/sigc++2/sigc++/adaptors/exception_catch.h
View file

@ -1,319 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_
#define _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_
#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::execption_catch() returns can be passed into
* sigc::signal::connect() directly.
*
* @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;
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 type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type type; };
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<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_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)
{}
protected:
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;
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<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_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() {}
protected:
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_(); }
}
template <class T_action, class T_functor, class T_catcher, class T_return>
void visit_each(const T_action& _A_action,
const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
{
visit_each(_A_action, _A_target.functor_);
visit_each(_A_action, _A_target.catcher_);
}
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_MACROS_EXCEPTION_CATCHHM4_ */

1063
libs/sigc++2/sigc++/adaptors/hide.h
View file

File diff suppressed because it is too large Load diff

1
libs/sigc++2/sigc++/adaptors/lambda/.cvsignore
View file

@ -1 +0,0 @@
*.os

392
libs/sigc++2/sigc++/adaptors/lambda/base.h
View file

@ -1,392 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_LAMBDA_BASE_HPP_
#define _SIGC_LAMBDA_BASE_HPP_
#include <sigc++/adaptors/adaptor_trait.h>
namespace sigc {
/** @defgroup lambdas Lambdas
* libsigc++ ships with basic lambda functionality and the sigc::group adaptor that uses lambdas to transform a functor's parameter list.
*
* The lambda selectors sigc::_1, sigc::_2, ..., sigc::_9 are used to select the
* first, second, ..., nineth 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 lambda selectors can be used e.g. 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
*/
/** A hint to the compiler.
* All lambda types publically inherit from this hint.
*
* @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.
*/
template <class T_type, bool I_islambda = is_base_and_derived<lambda_base, T_type>::value> struct lambda_core;
/// Abstracts lambda functionality (template specialization for lambda values).
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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::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<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_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_;
};
template <class T_type>
typename lambda_core<T_type, true>::result_type
lambda_core<T_type, true>::operator()() const
{ return value_(); }
/// Abstracts lambda functionality (template specialization for other value types).
template <class T_type>
struct lambda_core<T_type, false> : 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_type type; };
typedef T_type result_type; // all operator() overloads return T_type.
typedef lambda<T_type> lambda_type;
result_type operator()() const;
template <class T_arg1>
result_type operator ()(T_arg1 _A_1) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
result_type sun_forte_workaround(T_arg1 _A_1) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
result_type operator ()(T_arg1 _A_1,T_arg2 _A_2) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
result_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_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
result_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_; }
#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>
result_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_; }
#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>
result_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_; }
#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>
result_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_; }
#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>
result_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_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
explicit lambda_core(typename type_trait<T_type>::take v)
: value_(v) {}
T_type value_;
};
template <class T_type>
typename lambda_core<T_type, false>::result_type lambda_core<T_type, false>::operator()() const
{ return value_; }
} /* namespace internal */
template <class T_action, class T_functor, bool I_islambda>
void visit_each(const T_action& _A_action,
const internal::lambda_core<T_functor, I_islambda>& _A_target)
{
visit_each(_A_action, _A_target.value_);
}
// 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.
*
* @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))); }
};
template <class T_action, class T_type>
void visit_each(const T_action& _A_action,
const lambda<T_type>& _A_target)
{
visit_each(_A_action, _A_target.value_);
}
/// Converts a reference into a lambda object.
template <class T_type>
lambda<T_type&> var(T_type& v)
{ return lambda<T_type&>(v); }
/// Converts a constant reference into a lambda object.
template <class T_type>
lambda<const T_type&> var(const T_type& v)
{ return lambda<const T_type&>(v); }
/** Deduces the type of the object stored in an object of the passed lambda type.
* If the type passed as template argument is no lambda type,
* type is defined to unwrap_reference<T_type>::type.
*/
template <class T_type>
struct unwrap_lambda_type
{ typedef typename unwrap_reference<T_type>::type type; };
template <class T_type>
struct unwrap_lambda_type<lambda<T_type> >
{ typedef T_type type; };
/** Gets the object stored inside a lambda object.
* Returns the object passed as argument if it is not of type lambda.
*/
template <class T_type>
T_type& unwrap_lambda_value(T_type& a)
{ return a; }
template <class T_type>
const T_type& unwrap_lambda_value(const T_type& a)
{ return a; }
template <class T_type>
const T_type& unwrap_lambda_value(const lambda<T_type>& a)
{ return a.value_; }
} /* namespace sigc */
#endif /* _SIGC_LAMBDA_BASE_HPP_ */

734
libs/sigc++2/sigc++/adaptors/lambda/group.h
View file

@ -1,734 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_ADAPTORS_LAMBDA_MACROS_GROUPHM4_
#define _SIGC_ADAPTORS_LAMBDA_MACROS_GROUPHM4_
#include <sigc++/adaptors/lambda/base.h>
/** @defgroup group_ group()
* sigc::group() alters an arbitrary functor by rebuilding its arguments from one or more lambda expressions.
* For each parameter that should be passed to the wrapped functor one lambda expression
* has to be passed into group(). Lambda selectors can be used as placeholders for the
* arguments passed into the new functor. Arguments that don't have a placeholder in one
* of the lambda expressions are dropped.
*
* @par Examples:
* @code
* void foo(int, int);
* int bar(int);
* // argument binding ...
* sigc::group(&foo,10,sigc::_1)(20); //fixes the first argument and calls foo(10,20)
* sigc::group(&foo,sigc::_1,30)(40); //fixes the second argument and calls foo(40,30)
* // argument reordering ...
* sigc::group(&foo,sigc::_2,sigc::_1)(1,2); //calls foo(2,1)
* // argument hiding ...
* sigc::group(&foo,sigc::_1,sigc::_2)(1,2,3); //calls foo(1,2)
* // functor composition ...
* sigc::group(&foo,sigc::_1,sigc::group(&bar,sigc::_2))(1,2); //calls foo(1,bar(2))
* // algebraic expressions ...
* sigc::group(&foo,sigc::_1*sigc::_2,sigc::_1/sigc::_2)(6,3); //calls foo(6*3,6/3)
* @endcode
*
* The functor sigc::group() returns can be passed into
* sigc::signal::connect() directly.
*
* @par Example:
* @code
* sigc::signal<void,int,int> some_signal;
* void foo(int);
* some_signal.connect(sigc::group(&foo,sigc::_2));
* @endcode
*
* Like in sigc::bind() you can bind references to functors by passing the objects
* through the sigc::ref() helper function.
*
* @par Example:
* @code
* int some_int;
* sigc::signal<void> some_signal;
* void foo(int&);
* some_signal.connect(sigc::group(&foo,sigc::ref(some_int)));
* @endcode
*
* If you bind an object of a sigc::trackable derived type to a functor
* by reference, a slot assigned to the group 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::group(&foo,sigc::ref(some_bar)));
* // disconnected automatically if some_bar goes out of scope
* @endcode
*
* @ingroup adaptors, lambdas
*/
namespace sigc {
template <class T_functor, class T_type1>
struct lambda_group1 : public lambda_base
{
typedef typename functor_trait<T_functor>::result_type result_type;
typedef typename lambda<T_type1>::lambda_type value1_type;
typedef typename adaptor_trait<T_functor>::adaptor_type functor_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 functor_type::template deduce_result_type<
typename value1_type::template deduce_result_type<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type
>::type type; };
result_type
operator ()() const;
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator() (T_arg1 _A_1) const
{ return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
lambda_group1(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_1)
: value1_(_A_1), func_(_A_func) {}
value1_type value1_;
mutable functor_type func_;
};
template <class T_functor, class T_type1>
typename lambda_group1<T_functor, T_type1>::result_type
lambda_group1<T_functor, T_type1>::operator ()() const
{ return func_(value1_()); }
template <class T_action, class T_functor, class T_type1>
void visit_each(const T_action& _A_action,
const lambda_group1<T_functor, T_type1>& _A_target)
{
visit_each(_A_action, _A_target.value1_);
visit_each(_A_action, _A_target.func_);
}
template <class T_functor, class T_type1,class T_type2>
struct lambda_group2 : public lambda_base
{
typedef typename functor_trait<T_functor>::result_type result_type;
typedef typename lambda<T_type1>::lambda_type value1_type;
typedef typename lambda<T_type2>::lambda_type value2_type;
typedef typename adaptor_trait<T_functor>::adaptor_type functor_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 functor_type::template deduce_result_type<
typename value1_type::template deduce_result_type<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type,
typename value2_type::template deduce_result_type<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type
>::type type; };
result_type
operator ()() const;
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator() (T_arg1 _A_1) const
{ return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1>::type,
typename value2_type::template deduce_result_type<T_arg1>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_A_1),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1>::type,
typename value2_type::template deduce_result_type<T_arg1>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_A_1),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
lambda_group2(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_1,typename type_trait<T_type2>::take _A_2)
: value1_(_A_1),value2_(_A_2), func_(_A_func) {}
value1_type value1_;
value2_type value2_;
mutable functor_type func_;
};
template <class T_functor, class T_type1,class T_type2>
typename lambda_group2<T_functor, T_type1,T_type2>::result_type
lambda_group2<T_functor, T_type1,T_type2>::operator ()() const
{ return func_(value1_(),value2_()); }
template <class T_action, class T_functor, class T_type1,class T_type2>
void visit_each(const T_action& _A_action,
const lambda_group2<T_functor, T_type1,T_type2>& _A_target)
{
visit_each(_A_action, _A_target.value1_);
visit_each(_A_action, _A_target.value2_);
visit_each(_A_action, _A_target.func_);
}
template <class T_functor, class T_type1,class T_type2,class T_type3>
struct lambda_group3 : public lambda_base
{
typedef typename functor_trait<T_functor>::result_type result_type;
typedef typename lambda<T_type1>::lambda_type value1_type;
typedef typename lambda<T_type2>::lambda_type value2_type;
typedef typename lambda<T_type3>::lambda_type value3_type;
typedef typename adaptor_trait<T_functor>::adaptor_type functor_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 functor_type::template deduce_result_type<
typename value1_type::template deduce_result_type<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type,
typename value2_type::template deduce_result_type<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type,
typename value3_type::template deduce_result_type<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type
>::type type; };
result_type
operator ()() const;
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator() (T_arg1 _A_1) const
{ return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1>::type,
typename value2_type::template deduce_result_type<T_arg1>::type,
typename value3_type::template deduce_result_type<T_arg1>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_A_1),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_A_1),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1>::type,
typename value2_type::template deduce_result_type<T_arg1>::type,
typename value3_type::template deduce_result_type<T_arg1>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_A_1),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_A_1),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_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 this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
lambda_group3(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_1,typename type_trait<T_type2>::take _A_2,typename type_trait<T_type3>::take _A_3)
: value1_(_A_1),value2_(_A_2),value3_(_A_3), func_(_A_func) {}
value1_type value1_;
value2_type value2_;
value3_type value3_;
mutable functor_type func_;
};
template <class T_functor, class T_type1,class T_type2,class T_type3>
typename lambda_group3<T_functor, T_type1,T_type2,T_type3>::result_type
lambda_group3<T_functor, T_type1,T_type2,T_type3>::operator ()() const
{ return func_(value1_(),value2_(),value3_()); }
template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3>
void visit_each(const T_action& _A_action,
const lambda_group3<T_functor, T_type1,T_type2,T_type3>& _A_target)
{
visit_each(_A_action, _A_target.value1_);
visit_each(_A_action, _A_target.value2_);
visit_each(_A_action, _A_target.value3_);
visit_each(_A_action, _A_target.func_);
}
template <class T_functor, class T_type1>
lambda<lambda_group1<T_functor, typename unwrap_reference<T_type1>::type> >
group(const T_functor& _A_func, T_type1 _A_1)
{
typedef lambda_group1<T_functor, typename unwrap_reference<T_type1>::type> T_lambda;
return lambda<T_lambda>(T_lambda(_A_func, _A_1));
}
template <class T_functor, class T_type1,class T_type2>
lambda<lambda_group2<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type> >
group(const T_functor& _A_func, T_type1 _A_1,T_type2 _A_2)
{
typedef lambda_group2<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type> T_lambda;
return lambda<T_lambda>(T_lambda(_A_func, _A_1,_A_2));
}
template <class T_functor, class T_type1,class T_type2,class T_type3>
lambda<lambda_group3<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type,typename unwrap_reference<T_type3>::type> >
group(const T_functor& _A_func, T_type1 _A_1,T_type2 _A_2,T_type3 _A_3)
{
typedef lambda_group3<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type,typename unwrap_reference<T_type3>::type> T_lambda;
return lambda<T_lambda>(T_lambda(_A_func, _A_1,_A_2,_A_3));
}
} /* namespace sigc */
#endif /* _SIGC_ADAPTORS_LAMBDA_MACROS_GROUPHM4_ */

15
libs/sigc++2/sigc++/adaptors/lambda/lambda.cc
View file

@ -1,15 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#include <sigc++/adaptors/lambda/select.h>
namespace sigc {
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 */

28
libs/sigc++2/sigc++/adaptors/lambda/lambda.h
View file

@ -1,28 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _SIGC_LAMBDA_HPP_
#define _SIGC_LAMBDA_HPP_
#include <sigc++/adaptors/lambda/base.h>
#include <sigc++/adaptors/lambda/select.h>
#include <sigc++/adaptors/lambda/operator.h>
#include <sigc++/adaptors/lambda/group.h>
#endif /* _SIGC_LAMBDA_HPP_ */

1697
libs/sigc++2/sigc++/adaptors/lambda/operator.h
View file

File diff suppressed because it is too large Load diff

346
libs/sigc++2/sigc++/adaptors/lambda/select.h
View file

@ -1,346 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_LAMBDA_SELECT_HPP_
#define _SIGC_LAMBDA_SELECT_HPP_
#include <sigc++/adaptors/lambda/base.h>
namespace sigc {
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 _A_2) 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 _A_2) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3>
T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) 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 _A_2,T_arg3 _A_3) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) 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 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) 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 _A_1,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 _A_1,T_arg2 _A_2) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3>
T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _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 _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 _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 _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 _A_1,T_arg2 _A_2,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 _A_1,T_arg2 _A_2,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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _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 _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 _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 _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 _A_1,T_arg2 _A_2,T_arg3 _A_3,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 _A_1,T_arg2 _A_2,T_arg3 _A_3,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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _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 _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 _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 _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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) 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 _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 _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 _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 _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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,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 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,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 _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 _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 _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 _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 _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 _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 _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 _A_7; }
#endif
};
} /* namespace internal */
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;
} /* namespace sigc */
#endif /* _SIGC_LAMBDA_SELECT_HPP_ */

1247
libs/sigc++2/sigc++/adaptors/retype.h
View file

File diff suppressed because it is too large Load diff

308
libs/sigc++2/sigc++/adaptors/retype_return.h
View file

@ -1,308 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_ADAPTORS_MACROS_RETYPE_RETURNHM4_
#define _SIGC_ADAPTORS_MACROS_RETYPE_RETURNHM4_
#include <sigc++/adaptors/adaptor_trait.h>
namespace sigc {
/** Adaptor that perform 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>
{
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; };
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<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_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(typename type_trait<T_functor>::take _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 perform 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 needed because of explicit cast to T_return.
*/
template <class T_functor>
struct retype_return_functor<void, T_functor> : public adapts<T_functor>
{
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; };
typedef void result_type;
void operator()();
template <class T_arg1>
inline void operator()(T_arg1 _A_a1)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_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<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
}
#endif
retype_return_functor() {}
retype_return_functor(typename type_trait<T_functor>::take _A_functor)
: adapts<T_functor>(_A_functor)
{}
};
template <class T_functor>
void retype_return_functor<void, T_functor>::operator()()
{ this->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_action, class T_return, class T_functor>
void visit_each(const T_action& _A_action,
const retype_return_functor<T_return, T_functor>& _A_target)
{
visit_each(_A_action, _A_target.functor_);
}
/** 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 casts 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_MACROS_RETYPE_RETURNHM4_ */

65
libs/sigc++2/sigc++/bind.h
View file

@ -1,65 +0,0 @@
/*
* 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>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
template <class T_bound1, class T_functor>
inline ::sigc::bind_functor<-1, T_functor,
typename ::sigc::unwrap_reference<T_bound1>::type>
bind(const T_functor& _A_functor, T_bound1 _A_b1)
{ return ::sigc::bind_functor<-1, T_functor,
typename ::sigc::unwrap_reference<T_bound1>::type>
(_A_functor, _A_b1);
}
template <class T_bound1, class T_bound2, class T_functor>
inline ::sigc::bind_functor<-1, T_functor,
typename ::sigc::unwrap_reference<T_bound1>::type,
typename ::sigc::unwrap_reference<T_bound2>::type>
bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2)
{ return ::sigc::bind_functor<-1, T_functor,
typename ::sigc::unwrap_reference<T_bound1>::type,
typename ::sigc::unwrap_reference<T_bound2>::type>
(_A_functor, _A_b1, _A_b2);
}
template <class T_bound1, class T_bound2, class T_bound3, class T_functor>
inline ::sigc::bind_functor<-1, T_functor,
typename ::sigc::unwrap_reference<T_bound1>::type,
typename ::sigc::unwrap_reference<T_bound2>::type,
typename ::sigc::unwrap_reference<T_bound3>::type>
bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2,T_bound3 _A_b3)
{ return ::sigc::bind_functor<-1, T_functor,
typename ::sigc::unwrap_reference<T_bound1>::type,
typename ::sigc::unwrap_reference<T_bound2>::type,
typename ::sigc::unwrap_reference<T_bound3>::type>
(_A_functor, _A_b1, _A_b2, _A_b3);
}
}
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_BIND_HPP_ */

34
libs/sigc++2/sigc++/bind_return.h
View file

@ -1,34 +0,0 @@
/*
* 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>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
using ::sigc::bind_return;
}
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_BIND_RETURN_HPP_ */

568
libs/sigc++2/sigc++/class_slot.h
View file

@ -1,568 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_MACROS_CLASS_SLOTHM4_
#define _SIGC_MACROS_CLASS_SLOTHM4_
#include <sigc++/slot.h>
#include <sigc++/functors/mem_fun.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
// slot_class()
/** Creates a functor of type SigC::Slot0 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot0<T_return>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)() )
{ return ::sigc::bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot1<T_return, T_arg1>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1) )
{ return ::sigc::bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot2<T_return, T_arg1,T_arg2>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2) )
{ return ::sigc::bound_mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) )
{ return ::sigc::bound_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) )
{ return ::sigc::bound_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) )
{ return ::sigc::bound_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) )
{ return ::sigc::bound_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot7 that encapsulates a method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) )
{ return ::sigc::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); }
/** Creates a functor of type SigC::Slot0 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot0<T_return>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)() const)
{ return ::sigc::bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot1<T_return, T_arg1>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1) const)
{ return ::sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot2<T_return, T_arg1,T_arg2>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2) const)
{ return ::sigc::bound_const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) const)
{ return ::sigc::bound_const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) const)
{ return ::sigc::bound_const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const)
{ return ::sigc::bound_const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const)
{ return ::sigc::bound_const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot7 that encapsulates a const method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const)
{ return ::sigc::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); }
/** Creates a functor of type SigC::Slot0 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot0<T_return>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)() volatile)
{ return ::sigc::bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot1<T_return, T_arg1>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1) volatile)
{ return ::sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot2<T_return, T_arg1,T_arg2>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2) volatile)
{ return ::sigc::bound_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) volatile)
{ return ::sigc::bound_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) volatile)
{ return ::sigc::bound_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) volatile)
{ return ::sigc::bound_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) volatile)
{ return ::sigc::bound_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot7 that encapsulates a volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot_class( T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) volatile)
{ return ::sigc::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); }
/** Creates a functor of type SigC::Slot0 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot0<T_return>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)() const volatile)
{ return ::sigc::bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot1<T_return, T_arg1>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1) const volatile)
{ return ::sigc::bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot2<T_return, T_arg1,T_arg2>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2) const volatile)
{ return ::sigc::bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) const volatile)
{ return ::sigc::bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) const volatile)
{ return ::sigc::bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const volatile)
{ return ::sigc::bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const volatile)
{ return ::sigc::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); }
/** Creates a functor of type SigC::Slot7 that encapsulates a const volatile method and an object instance.
*
* This function is part of the compatibility module and therefore deprecated.
* Use sigc::mem_fun() instead.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot_class(const T_obj& _A_obj, T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const volatile)
{ return ::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_obj, _A_func); }
}
#endif
#endif /* _SIGC_MACROS_CLASS_SLOTHM4_ */

42
libs/sigc++2/sigc++/compatibility.h
View file

@ -1,42 +0,0 @@
/*
* 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_COMPATIBILITY_HPP_
#define _SIGC_COMPATIBILITY_HPP_
#include <sigc++/signal.h>
#include <sigc++/connection.h>
#include <sigc++/object_slot.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
/** @defgroup compat Compatibility module
* This set of types and functions provides an API that is compatible to
* libsigc++-1.2. Some internal structures of libsigc++-1.2 are not available.
*
* All types and functions that are defined in namespace SigC are deprecated.
* Use the new libsigc++2 API that is defined in namespace sigc.
*/
}
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_COMPATIBILITY_HPP_ */

111
libs/sigc++2/sigc++/connection.cc
View file

@ -1,111 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <sigc++/connection.h>
using namespace std;
namespace sigc {
connection::connection()
: slot_(0)
{}
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, &notify);
}
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, &notify);
}
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
{
return (!slot_ || slot_->empty());
}
bool connection::connected() const
{
return !empty();
}
bool connection::blocked() const
{
return (slot_ ? slot_->blocked() : false);
}
bool connection::block(bool should_block)
{
return (slot_ ? slot_->block(should_block) : false);
}
bool connection::unblock()
{
return (slot_ ? slot_->unblock() : false);
}
void connection::disconnect()
{
if (slot_)
slot_->disconnect(); // This notifies slot_'s parent.
}
connection::operator bool()
{
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, &notify);
}
void* connection::notify(void* data)
{
connection* self = (connection*)data;
self->slot_ = 0;
return 0;
}
} /* namespace sigc */

154
libs/sigc++2/sigc++/connection.h
View file

@ -1,154 +0,0 @@
/*
* 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();
/** 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, &notify); }
/** 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;
/** Returns whether the connection is still active.
* @return @p true if the connection is still active.
*/
bool connected() const;
/** Returns whether the connection is blocked.
* @return @p true if the connection is blocked.
*/
bool blocked() const;
/** 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);
/** Unsets the blocking state of this connection.
* @return @p true if the connection has been in blocking state before.
*/
bool unblock();
/// Disconnects the referred slot.
void disconnect();
/** Returns whether the connection is still active.
* @return @p true if the connection is still active.
*/
operator bool();
/** Callback that is executed when the referred slot is destroyed.
* @param d 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 */
#ifndef LIBSIGC_DISABLE_DEPRECATED
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()).
*
* @deprecated Use sigc::connection instead.
* @ingroup compat
*/
typedef ::sigc::connection Connection;
}
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_TRACKABLE_HPP_ */

1
libs/sigc++2/sigc++/functors/.cvsignore
View file

@ -1 +0,0 @@
*.os

307
libs/sigc++2/sigc++/functors/functor_trait.h
View file

@ -1,307 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
/*
Trait functor_trait<functor>:
This trait allows the user to specific what is the return type
of any type. It has been overloaded to detect the return type and
the functor version of function pointers and class methods as well.
To populate the return type of user defined and third party functors
use the macro SIGC_FUNCTOR_TRAIT(T_functor,T_return) in
namespace sigc. Multi-type functors are only partly supported.
Try specifying the return type of the functor's operator()() overload.
Alternatively, you can derive your functors from functor_base and
place "typedef T_return result_type;" in the class definition.
Use SIGC_FUNCTORS_HAVE_RESULT_TYPE if you want sigc++ to assume that
result_type is defined in all user defined or 3rd-party functors
(except those you specify a return type explicitly with SIGC_FUNCTOR_TRAIT()).
*/
#ifndef _SIGC_FUNCTORS_MACROS_FUNCTOR_TRAITHM4_
#define _SIGC_FUNCTORS_MACROS_FUNCTOR_TRAITHM4_
#include <sigc++/type_traits.h>
namespace sigc {
/** 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
*/
struct nil_;
/** @defgroup functors 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 partly 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 libaray, 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 equally named module.
*/
/** A hint to the compiler.
* All functors which define @p result_type should publically inherit from this hint.
*
* @ingroup functors
*/
struct functor_base {};
template <class T_functor, bool I_derives_functor_base=is_base_and_derived<functor_base,T_functor>::value>
struct functor_trait
{
typedef void result_type;
typedef T_functor functor_type;
};
template <class T_functor>
struct functor_trait<T_functor,true>
{
typedef typename T_functor::result_type result_type;
typedef T_functor functor_type;
};
/** If you want to mix functors from a different library with libsigc++ and
* these functors define @p result_type simply use this macro inside namespace sigc like so:
* @code
* namespace sigc { SIGC_FUNCTORS_HAVE_RESULT_TYPE }
* @endcode
*
* @ingroup functors
*/
#define SIGC_FUNCTORS_HAVE_RESULT_TYPE \
template <class T_functor> \
struct functor_trait<T_functor,false> \
{ \
typedef typename T_functor::result_type result_type; \
typedef T_functor functor_type; \
};
/** If you want to mix functors from a different library 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 functors
*/
#define SIGC_FUNCTOR_TRAIT(T_functor,T_return) \
template <> \
struct functor_trait<T_functor,false> \
{ \
typedef T_return result_type; \
typedef T_functor functor_type; \
};
// 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>
{
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>
{
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>
{
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>
{
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>
{
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>
{
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>
{
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>
{
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>
{
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>
{
typedef T_return result_type;
typedef const_mem_functor0<T_return, T_obj> functor_type;
};
template <class T_arg1, class T_return, class T_obj> class mem_functor1;
template <class T_arg1, class T_return, class T_obj> class const_mem_functor1;
template <class T_arg1, class T_return, class T_obj>
struct functor_trait<T_return (T_obj::*)(T_arg1), false>
{
typedef T_return result_type;
typedef mem_functor1<T_arg1, T_return, T_obj> functor_type;
};
template <class T_arg1, class T_return, class T_obj>
struct functor_trait<T_return (T_obj::*)(T_arg1) const, false>
{
typedef T_return result_type;
typedef const_mem_functor1<T_arg1, T_return, T_obj> functor_type;
};
template <class T_arg1,class T_arg2, class T_return, class T_obj> class mem_functor2;
template <class T_arg1,class T_arg2, class T_return, class T_obj> 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>
{
typedef T_return result_type;
typedef mem_functor2<T_arg1,T_arg2, T_return, T_obj> 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>
{
typedef T_return result_type;
typedef const_mem_functor2<T_arg1,T_arg2, T_return, T_obj> functor_type;
};
template <class T_arg1,class T_arg2,class T_arg3, class T_return, class T_obj> class mem_functor3;
template <class T_arg1,class T_arg2,class T_arg3, class T_return, class T_obj> 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>
{
typedef T_return result_type;
typedef mem_functor3<T_arg1,T_arg2,T_arg3, T_return, T_obj> 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>
{
typedef T_return result_type;
typedef const_mem_functor3<T_arg1,T_arg2,T_arg3, T_return, T_obj> functor_type;
};
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_return, class T_obj> class mem_functor4;
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_return, class T_obj> 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>
{
typedef T_return result_type;
typedef mem_functor4<T_arg1,T_arg2,T_arg3,T_arg4, T_return, T_obj> 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>
{
typedef T_return result_type;
typedef const_mem_functor4<T_arg1,T_arg2,T_arg3,T_arg4, T_return, T_obj> functor_type;
};
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_return, class T_obj> class mem_functor5;
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_return, class T_obj> 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>
{
typedef T_return result_type;
typedef mem_functor5<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_return, T_obj> 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>
{
typedef T_return result_type;
typedef const_mem_functor5<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_return, T_obj> 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> class 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> 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>
{
typedef T_return result_type;
typedef mem_functor6<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_return, T_obj> 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>
{
typedef T_return result_type;
typedef const_mem_functor6<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_return, T_obj> 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> class 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> 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>
{
typedef T_return result_type;
typedef mem_functor7<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_return, T_obj> 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>
{
typedef T_return result_type;
typedef const_mem_functor7<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_return, T_obj> functor_type;
};
} /* namespace sigc */
#endif /* _SIGC_FUNCTORS_MACROS_FUNCTOR_TRAITHM4_ */

27
libs/sigc++2/sigc++/functors/functors.h
View file

@ -1,27 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#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_ */

5976
libs/sigc++2/sigc++/functors/mem_fun.h
View file

File diff suppressed because it is too large Load diff

542
libs/sigc++2/sigc++/functors/ptr_fun.h
View file

@ -1,542 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_FUNCTORS_MACROS_PTR_FUNHM4_
#define _SIGC_FUNCTORS_MACROS_PTR_FUNHM4_
#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 abiguity 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 functors
*/
/** 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()(typename type_trait<T_arg1>::take _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()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _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()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _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()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _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()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _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()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _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()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _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_MACROS_PTR_FUNHM4_ */

25
libs/sigc++2/sigc++/functors/slot.cc
View file

@ -1,25 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <sigc++/functors/slot.h>
namespace sigc {
} /* namespace sigc */

1263
libs/sigc++2/sigc++/functors/slot.h
View file

File diff suppressed because it is too large Load diff

165
libs/sigc++2/sigc++/functors/slot_base.cc
View file

@ -1,165 +0,0 @@
// -*- c++ -*-
/*
* 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 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()
{
if (parent_)
{
call_ = 0; // 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.
void* data_ = parent_;
parent_ = 0; // Just a precaution.
(cleanup_)(data_); // Notify the parent (might lead to destruction of this!).
}
}
//static
void* slot_rep::notify(void* data)
{
slot_rep* self_ = (slot_rep*)data;
self_->call_ = 0; // Invalidate the slot.
self_->destroy(); // Detach the stored functor from the other referred trackables and destroy it.
self_->disconnect(); // Disconnect the slot (might lead to deletion of self_!).
return 0;
}
} // namespace internal
slot_base::slot_base()
: rep_(0),
blocked_(false)
{}
slot_base::slot_base(rep_type* rep)
: rep_(rep),
blocked_(false)
{}
slot_base::slot_base(const slot_base& src)
: rep_(0),
blocked_(src.blocked_)
{
if (src.rep_)
rep_ = src.rep_->dup();
}
slot_base::~slot_base()
{
if (rep_)
delete rep_;
}
slot_base::operator bool() const
{
return rep_ != 0;
}
slot_base& slot_base::operator=(const slot_base& src)
{
if (src.rep_ == rep_) return *this;
if (src.empty())
{
disconnect();
return *this;
}
internal::slot_rep* new_rep_ = src.rep_->dup();
if (rep_) // Silently exchange the slot_rep.
{
new_rep_->set_parent(rep_->parent_, rep_->cleanup_);
delete rep_;
}
rep_ = new_rep_;
return *this;
}
void slot_base::set_parent(void* parent, void* (*cleanup)(void*)) const
{
if (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)
{
bool old = blocked_;
blocked_ = should_block;
return old;
}
bool slot_base::unblock()
{
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_ = 0; // safe to wait for the destructor to delete the slot_rep. Martin.
}
return (rep_ == 0);
}*/
} //namespace sigc

319
libs/sigc++2/sigc++/functors/slot_base.h
View file

@ -1,319 +0,0 @@
/*
* 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++2 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
{
/* 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__)
: call_(call__), destroy_(destroy__), dup_(dup__), cleanup_(0), parent_(0) {}
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 (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)
{
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) : 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) : 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, regardless of whether it is a global function,
* a member method, static, or virtual.
*
* Use the sigc::mem_fun() and sigc::ptr_fun() template functions to get a sigc::slot, like so:
*
* @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
*
* @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.
*
* @ingroup functors
*/
/** 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;
public:
/// Constructs an empty slot.
slot_base();
/** 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);
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
slot_base(const 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
*/
operator bool() const;
/** 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;
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
{ return (!rep_ || !rep_->call_); }
/** Returns whether the slot is blocked.
* @return @p true if the slot is blocked.
*/
inline bool blocked() const
{ 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);
/** Unsets the blocking state.
* @return @p true if the slot was in blocking state before.
*/
bool unblock();
/** Disconnects the slot.
* Invalidates the slot and notifies the parent.
*/
void disconnect();
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);
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_;
};
} //namespace sigc
#endif //_SIGC_SLOT_BASE_HPP_

105
libs/sigc++2/sigc++/hide.h
View file

@ -1,105 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_MACROS_HIDEHM4_
#define _SIGC_MACROS_HIDEHM4_
#include <sigc++/slot.h>
#include <sigc++/adaptors/hide.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
template <class T_hidden1, class T_return>
inline SigC::Slot1<T_return, T_hidden1>
hide(const SigC::Slot0<T_return>& _A_slot)
{ return ::sigc::hide_functor<0, SigC::Slot0<T_return> >
(_A_slot); }
template <class T_hidden1, class T_return, class T_arg1>
inline SigC::Slot2<T_return, T_arg1, T_hidden1>
hide(const SigC::Slot1<T_return, T_arg1>& _A_slot)
{ return ::sigc::hide_functor<0, SigC::Slot1<T_return, T_arg1> >
(_A_slot); }
template <class T_hidden1, class T_return, class T_arg1,class T_arg2>
inline SigC::Slot3<T_return, T_arg1,T_arg2, T_hidden1>
hide(const SigC::Slot2<T_return, T_arg1,T_arg2>& _A_slot)
{ return ::sigc::hide_functor<0, SigC::Slot2<T_return, T_arg1,T_arg2> >
(_A_slot); }
template <class T_hidden1, class T_return, class T_arg1,class T_arg2,class T_arg3>
inline SigC::Slot4<T_return, T_arg1,T_arg2,T_arg3, T_hidden1>
hide(const SigC::Slot3<T_return, T_arg1,T_arg2,T_arg3>& _A_slot)
{ return ::sigc::hide_functor<0, SigC::Slot3<T_return, T_arg1,T_arg2,T_arg3> >
(_A_slot); }
template <class T_hidden1, class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline SigC::Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_hidden1>
hide(const SigC::Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>& _A_slot)
{ return ::sigc::hide_functor<0, SigC::Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> >
(_A_slot); }
template <class T_hidden1, class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline SigC::Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_hidden1>
hide(const SigC::Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_slot)
{ return ::sigc::hide_functor<0, SigC::Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >
(_A_slot); }
template <class T_hidden1, class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline SigC::Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_hidden1>
hide(const SigC::Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_slot)
{ return ::sigc::hide_functor<0, SigC::Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >
(_A_slot); }
template <class T_hidden1,class T_hidden2, class T_return>
inline SigC::Slot2<T_return, T_hidden1,T_hidden2>
hide(const SigC::Slot0<T_return>& _A_slot)
{ return ::sigc::hide<0>(
::sigc::hide_functor<0, SigC::Slot0<T_return> >
(_A_slot)); }
template <class T_hidden1,class T_hidden2, class T_return, class T_arg1>
inline SigC::Slot3<T_return, T_arg1, T_hidden1,T_hidden2>
hide(const SigC::Slot1<T_return, T_arg1>& _A_slot)
{ return ::sigc::hide<0>(
::sigc::hide_functor<0, SigC::Slot1<T_return, T_arg1> >
(_A_slot)); }
template <class T_hidden1,class T_hidden2, class T_return, class T_arg1,class T_arg2>
inline SigC::Slot4<T_return, T_arg1,T_arg2, T_hidden1,T_hidden2>
hide(const SigC::Slot2<T_return, T_arg1,T_arg2>& _A_slot)
{ return ::sigc::hide<0>(
::sigc::hide_functor<0, SigC::Slot2<T_return, T_arg1,T_arg2> >
(_A_slot)); }
template <class T_hidden1,class T_hidden2, class T_return, class T_arg1,class T_arg2,class T_arg3>
inline SigC::Slot5<T_return, T_arg1,T_arg2,T_arg3, T_hidden1,T_hidden2>
hide(const SigC::Slot3<T_return, T_arg1,T_arg2,T_arg3>& _A_slot)
{ return ::sigc::hide<0>(
::sigc::hide_functor<0, SigC::Slot3<T_return, T_arg1,T_arg2,T_arg3> >
(_A_slot)); }
template <class T_hidden1,class T_hidden2, class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline SigC::Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_hidden1,T_hidden2>
hide(const SigC::Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>& _A_slot)
{ return ::sigc::hide<0>(
::sigc::hide_functor<0, SigC::Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> >
(_A_slot)); }
template <class T_hidden1,class T_hidden2, class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline SigC::Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_hidden1,T_hidden2>
hide(const SigC::Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_slot)
{ return ::sigc::hide<0>(
::sigc::hide_functor<0, SigC::Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >
(_A_slot)); }
} /* namespace SigC */
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_MACROS_HIDEHM4_ */

387
libs/sigc++2/sigc++/method_slot.h
View file

@ -1,387 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_MACROS_METHOD_SLOTHM4_
#define _SIGC_MACROS_METHOD_SLOTHM4_
#include <sigc++/slot.h>
#include <sigc++/functors/mem_fun.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
/** Creates a functor of type Sigc::Slot1 that wraps a method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot1<T_return, T_obj&>
slot(T_return (T_obj::*_A_func)() )
{ return ::sigc::mem_functor0<T_return, T_obj>(_A_func); }
/** Creates a functor of type Sigc::Slot2 that wraps a method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot2<T_return, T_obj&, T_arg1>
slot(T_return (T_obj::*_A_func)(T_arg1) )
{ return ::sigc::mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
/** Creates a functor of type Sigc::Slot3 that wraps a method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot3<T_return, T_obj&, T_arg1,T_arg2>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2) )
{ return ::sigc::mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_func); }
/** Creates a functor of type Sigc::Slot4 that wraps a method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot4<T_return, T_obj&, T_arg1,T_arg2,T_arg3>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) )
{ return ::sigc::mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_func); }
/** Creates a functor of type Sigc::Slot5 that wraps a method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot5<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) )
{ return ::sigc::mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
/** Creates a functor of type Sigc::Slot6 that wraps a method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot6<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) )
{ return ::sigc::mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); }
/** Creates a functor of type Sigc::Slot7 that wraps a method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot7<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) )
{ return ::sigc::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::Slot1 that wraps a const method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot1<T_return, T_obj&>
slot(T_return (T_obj::*_A_func)() const)
{ return ::sigc::const_mem_functor0<T_return, T_obj>(_A_func); }
/** Creates a functor of type Sigc::Slot2 that wraps a const method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot2<T_return, T_obj&, T_arg1>
slot(T_return (T_obj::*_A_func)(T_arg1) const)
{ return ::sigc::const_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
/** Creates a functor of type Sigc::Slot3 that wraps a const method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot3<T_return, T_obj&, T_arg1,T_arg2>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2) const)
{ return ::sigc::const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_func); }
/** Creates a functor of type Sigc::Slot4 that wraps a const method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot4<T_return, T_obj&, T_arg1,T_arg2,T_arg3>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) const)
{ return ::sigc::const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_func); }
/** Creates a functor of type Sigc::Slot5 that wraps a const method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot5<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) const)
{ return ::sigc::const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
/** Creates a functor of type Sigc::Slot6 that wraps a const method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot6<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const)
{ return ::sigc::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::Slot7 that wraps a const method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot7<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const)
{ return ::sigc::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::Slot1 that wraps a volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot1<T_return, T_obj&>
slot(T_return (T_obj::*_A_func)() volatile)
{ return ::sigc::volatile_mem_functor0<T_return, T_obj>(_A_func); }
/** Creates a functor of type Sigc::Slot2 that wraps a volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot2<T_return, T_obj&, T_arg1>
slot(T_return (T_obj::*_A_func)(T_arg1) volatile)
{ return ::sigc::volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
/** Creates a functor of type Sigc::Slot3 that wraps a volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot3<T_return, T_obj&, T_arg1,T_arg2>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2) volatile)
{ return ::sigc::volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_func); }
/** Creates a functor of type Sigc::Slot4 that wraps a volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot4<T_return, T_obj&, T_arg1,T_arg2,T_arg3>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) volatile)
{ return ::sigc::volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_func); }
/** Creates a functor of type Sigc::Slot5 that wraps a volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot5<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) volatile)
{ return ::sigc::volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
/** Creates a functor of type Sigc::Slot6 that wraps a volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot6<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) volatile)
{ return ::sigc::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::Slot7 that wraps a volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot7<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) volatile)
{ return ::sigc::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::Slot1 that wraps a const volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj>
inline Slot1<T_return, T_obj&>
slot(T_return (T_obj::*_A_func)() const volatile)
{ return ::sigc::const_volatile_mem_functor0<T_return, T_obj>(_A_func); }
/** Creates a functor of type Sigc::Slot2 that wraps a const volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj>
inline Slot2<T_return, T_obj&, T_arg1>
slot(T_return (T_obj::*_A_func)(T_arg1) const volatile)
{ return ::sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
/** Creates a functor of type Sigc::Slot3 that wraps a const volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj>
inline Slot3<T_return, T_obj&, T_arg1,T_arg2>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2) const volatile)
{ return ::sigc::const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>(_A_func); }
/** Creates a functor of type Sigc::Slot4 that wraps a const volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj>
inline Slot4<T_return, T_obj&, T_arg1,T_arg2,T_arg3>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3) const volatile)
{ return ::sigc::const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>(_A_func); }
/** Creates a functor of type Sigc::Slot5 that wraps a const volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj>
inline Slot5<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) const volatile)
{ return ::sigc::const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
/** Creates a functor of type Sigc::Slot6 that wraps a const volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj>
inline Slot6<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const volatile)
{ return ::sigc::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::Slot7 that wraps a const volatile method.
*
* @param _A_func Pointer to method that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj>
inline Slot7<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(T_return (T_obj::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const volatile)
{ return ::sigc::const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); }
}
#endif
#endif /* _SIGC_MACROS_METHOD_SLOTHM4_ */

35
libs/sigc++2/sigc++/object.h
View file

@ -1,35 +0,0 @@
/*
* 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_OBJECT_HPP_
#define _SIGC_OBJECT_HPP_
#include <sigc++/trackable.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
// Object
typedef ::sigc::trackable Object;
}
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_OBJECT_HPP_ */

536
libs/sigc++2/sigc++/object_slot.h
View file

@ -1,536 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_MACROS_OBJECT_SLOTHM4_
#define _SIGC_MACROS_OBJECT_SLOTHM4_
#include <sigc++/slot.h>
#include <sigc++/object.h>
#include <sigc++/functors/mem_fun.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
/** Creates a functor of type SigC::Slot0 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj1, class T_obj2>
inline Slot0<T_return>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor0<T_return, T_obj2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj1, class T_obj2>
inline Slot1<T_return, T_arg1>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor1<T_return, T_obj2, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj1, class T_obj2>
inline Slot2<T_return, T_arg1,T_arg2>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2) )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor2<T_return, T_obj2, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj1, class T_obj2>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3) )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor3<T_return, T_obj2, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj1, class T_obj2>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor4<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj1, class T_obj2>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor5<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj1, class T_obj2>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor6<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot7 that encapsulates a method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj1, class T_obj2>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) )
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_mem_functor7<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot0 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj1, class T_obj2>
inline Slot0<T_return>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)() const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor0<T_return, T_obj2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj1, class T_obj2>
inline Slot1<T_return, T_arg1>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor1<T_return, T_obj2, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj1, class T_obj2>
inline Slot2<T_return, T_arg1,T_arg2>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2) const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor2<T_return, T_obj2, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj1, class T_obj2>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3) const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor3<T_return, T_obj2, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj1, class T_obj2>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor4<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj1, class T_obj2>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor5<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj1, class T_obj2>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor6<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot7 that encapsulates a const method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj1, class T_obj2>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_mem_functor7<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot0 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj1, class T_obj2>
inline Slot0<T_return>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor0<T_return, T_obj2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj1, class T_obj2>
inline Slot1<T_return, T_arg1>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor1<T_return, T_obj2, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj1, class T_obj2>
inline Slot2<T_return, T_arg1,T_arg2>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2) volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor2<T_return, T_obj2, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj1, class T_obj2>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3) volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor3<T_return, T_obj2, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj1, class T_obj2>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor4<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj1, class T_obj2>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor5<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj1, class T_obj2>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor6<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot7 that encapsulates a volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj1, class T_obj2>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) volatile)
{ (void)dynamic_cast< Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_volatile_mem_functor7<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot0 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_obj1, class T_obj2>
inline Slot0<T_return>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)() const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor0<T_return, T_obj2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot1 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1, class T_obj1, class T_obj2>
inline Slot1<T_return, T_arg1>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor1<T_return, T_obj2, T_arg1>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot2 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2, class T_obj1, class T_obj2>
inline Slot2<T_return, T_arg1,T_arg2>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2) const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor2<T_return, T_obj2, T_arg1,T_arg2>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot3 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_obj1, class T_obj2>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3) const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor3<T_return, T_obj2, T_arg1,T_arg2,T_arg3>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot4 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_obj1, class T_obj2>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4) const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor4<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot5 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_obj1, class T_obj2>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor5<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot6 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_obj1, class T_obj2>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor6<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_obj, _A_func); }
/** Creates a functor of type SigC::Slot7 that encapsulates a const volatile method and an object instance.
* @e _A_obj must be of a type that inherits from SigC::Object.
*
* @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 _A_func on invokation.
*
* @deprecated Use sigc::mem_fun() instead.
* @ingroup compat
*/
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_obj1, class T_obj2>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot(const T_obj1& _A_obj, T_return (T_obj2::*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const volatile)
{ (void)dynamic_cast<const Object&>(_A_obj); // trigger compiler error if T_obj1 does not derive from SigC::Object
return ::sigc::bound_const_volatile_mem_functor7<T_return, T_obj2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_obj, _A_func); }
}
#endif
#endif /* _SIGC_MACROS_OBJECT_SLOTHM4_ */

118
libs/sigc++2/sigc++/reference_wrapper.h
View file

@ -1,118 +0,0 @@
/*
* 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_
namespace sigc {
/** Reference wrapper.
* Use sigc::ref() to create a 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.
*/
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.
*/
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.
*/
template <class T_type>
const_reference_wrapper<T_type> ref(const T_type& v)
{ return const_reference_wrapper<T_type>(v); }
template <class T_type>
struct unwrap_reference
{
typedef T_type type;
};
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(T_type& v)
{ return v; }
template <class T_type>
const T_type& unwrap(const T_type& v)
{ return v; }
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; }
} /* namespace sigc */
#endif /* _SIGC_REFERENCE_WRAPPER_H_ */

321
libs/sigc++2/sigc++/retype.h
View file

@ -1,321 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_MACROS_RETYPEHM4_
#define _SIGC_MACROS_RETYPEHM4_
#include <sigc++/adaptors/adaptor_trait.h>
#include <sigc++/slot.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
template <class T_functor, class T_return, class T_type1=::sigc::nil_,class T_type2=::sigc::nil_,class T_type3=::sigc::nil_,class T_type4=::sigc::nil_,class T_type5=::sigc::nil_,class T_type6=::sigc::nil_,class T_type7=::sigc::nil_>
struct retype_slot_functor
: public ::sigc::adapts<T_functor>
{
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; };
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<typename ::sigc::type_trait<T_type1>::take>
((T_type1)_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<typename ::sigc::type_trait<T_type1>::take>
((T_type1)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
((T_type1)_A_a1,(T_type2)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
((T_type1)_A_a1,(T_type2)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(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>
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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(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>
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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(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>
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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(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>
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<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
}
#endif
retype_slot_functor(typename ::sigc::type_trait<T_functor>::take _A_functor)
: ::sigc::adapts<T_functor>(_A_functor)
{}
};
template <class T_functor, class T_return, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
T_return retype_slot_functor<T_functor, T_return, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
{ return T_return(this->functor_()); }
// void specialization needed because of explicit cast to T_return
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 retype_slot_functor<T_functor, void, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>
: public ::sigc::adapts<T_functor>
{
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; };
typedef void result_type;
void operator()();
template <class T_arg1>
inline void operator()(T_arg1 _A_a1)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
((T_type1)_A_a1));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
inline void sun_forte_workaround(T_arg1 _A_a1)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
((T_type1)_A_a1));
}
#endif
template <class T_arg1,class T_arg2>
inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
((T_type1)_A_a1,(T_type2)_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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
((T_type1)_A_a1,(T_type2)_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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(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>
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_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(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>
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_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(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>
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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(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>
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)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
}
#endif
retype_slot_functor(typename ::sigc::type_trait<T_functor>::take _A_functor)
: ::sigc::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>
void retype_slot_functor<T_functor, void, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
{ this->functor_(); }
template <class T_action, class T_functor, class T_return, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
void visit_each(const T_action& _A_action,
const retype_slot_functor<T_functor, T_return, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_target)
{
visit_each(_A_action, _A_target.functor_);
}
template <class T_return, class T_ret>
inline Slot0<T_return>
retype(const Slot0<T_ret>& _A_slot)
{ return Slot0<T_return>
(retype_slot_functor<Slot0<T_ret>, T_return>
(_A_slot)); }
template <class T_return, class T_arg1, class T_ret, class T_type1>
inline Slot1<T_return, T_arg1>
retype(const Slot1<T_ret, T_type1>& _A_slot)
{ return Slot1<T_return, T_arg1>
(retype_slot_functor<Slot1<T_ret, T_type1>, T_return, T_type1>
(_A_slot)); }
template <class T_return, class T_arg1,class T_arg2, class T_ret, class T_type1,class T_type2>
inline Slot2<T_return, T_arg1,T_arg2>
retype(const Slot2<T_ret, T_type1,T_type2>& _A_slot)
{ return Slot2<T_return, T_arg1,T_arg2>
(retype_slot_functor<Slot2<T_ret, T_type1, T_type2>, T_return, T_type1,T_type2>
(_A_slot)); }
template <class T_return, class T_arg1,class T_arg2,class T_arg3, class T_ret, class T_type1,class T_type2,class T_type3>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
retype(const Slot3<T_ret, T_type1,T_type2,T_type3>& _A_slot)
{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>
(retype_slot_functor<Slot3<T_ret, T_type1, T_type2, T_type3>, T_return, T_type1,T_type2,T_type3>
(_A_slot)); }
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_ret, class T_type1,class T_type2,class T_type3,class T_type4>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
retype(const Slot4<T_ret, T_type1,T_type2,T_type3,T_type4>& _A_slot)
{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
(retype_slot_functor<Slot4<T_ret, T_type1, T_type2, T_type3, T_type4>, T_return, T_type1,T_type2,T_type3,T_type4>
(_A_slot)); }
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_ret, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
retype(const Slot5<T_ret, T_type1,T_type2,T_type3,T_type4,T_type5>& _A_slot)
{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
(retype_slot_functor<Slot5<T_ret, T_type1, T_type2, T_type3, T_type4, T_type5>, T_return, T_type1,T_type2,T_type3,T_type4,T_type5>
(_A_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_ret, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
retype(const Slot6<T_ret, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>& _A_slot)
{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
(retype_slot_functor<Slot6<T_ret, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6>, T_return, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>
(_A_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 T_ret, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
retype(const Slot7<T_ret, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_slot)
{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
(retype_slot_functor<Slot7<T_ret, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>, T_return, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>
(_A_slot)); }
} /* namespace SigC */
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_MACROS_RETYPEHM4_ */

35
libs/sigc++2/sigc++/retype_return.h
View file

@ -1,35 +0,0 @@
/*
* 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>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
using ::sigc::retype_return;
using ::sigc::hide_return;
}
#endif /* LIBSIGC_DISABLE_DEPRECATED */
#endif /* _SIGC_RETYPE_RETURN_HPP_ */

30
libs/sigc++2/sigc++/sigc++.h
View file

@ -1,30 +0,0 @@
/*
* 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
#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 */

25
libs/sigc++2/sigc++/signal.cc
View file

@ -1,25 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <sigc++/signal.h>
namespace sigc {
} /* sigc */

3188
libs/sigc++2/sigc++/signal.h
View file

File diff suppressed because it is too large Load diff

151
libs/sigc++2/sigc++/signal_base.cc
View file

@ -1,151 +0,0 @@
// -*- c++ -*-
/*
* 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>
namespace sigc {
namespace internal {
signal_impl::signal_impl()
: ref_count_(0), exec_count_(0), deferred_(0)
{}
// 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()
{
slots_.clear();
}
signal_impl::size_type signal_impl::size() const
{
return slots_.size();
}
signal_impl::iterator_type signal_impl::connect(const slot_base& slot_)
{
return insert(slots_.end(), slot_);
}
signal_impl::iterator_type signal_impl::erase(iterator_type i)
{
return slots_.erase(i);
}
signal_impl::iterator_type signal_impl::insert(signal_impl::iterator_type i, const slot_base& slot_)
{
iterator_type temp = slots_.insert(i, slot_);
temp->set_parent(this, &notify);
return temp;
}
void signal_impl::sweep()
{
iterator_type i = slots_.begin();
while (i != slots_.end())
if ((*i).empty())
i = slots_.erase(i);
else
++i;
}
void* signal_impl::notify(void* d)
{
signal_impl* self = (signal_impl*)d;
if (self->exec_count_ == 0)
self->sweep();
else // This is occuring during signal emission.
self->deferred_ = true; // => sweep() will be called from ~signal_exec().
return 0; // This is safer because we don't have to care about our iterators in emit().
}
} /* namespace internal */
signal_base::signal_base()
: impl_(0)
{}
signal_base::signal_base(const signal_base& src)
: trackable(),
impl_(src.impl())
{
impl_->reference();
}
signal_base::~signal_base()
{
if (impl_)
impl_->unreference();
}
void signal_base::clear()
{
if (impl_)
impl_->clear();
}
signal_base::size_type signal_base::size() const
{
return (impl_ ? impl_->size() : 0);
}
signal_base::iterator_type signal_base::connect(const slot_base& slot_)
{
return impl()->connect(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::erase(iterator_type i)
{
return impl()->erase(i);
}
signal_base& signal_base::operator = (const signal_base& src)
{
if (impl_) impl_->unreference();
impl_ = src.impl();
impl_->reference();
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 */

261
libs/sigc++2/sigc++/signal_base.h
View file

@ -1,261 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _SIGC_SIGNAL_BASE_H_
#define _SIGC_SIGNAL_BASE_H_
#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>
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 sweep() directly or defers the execution of
* sweep() when the signal is being emitted. sweep() removes all
* invalid slot from the list.
*/
struct SIGC_API signal_impl
{
typedef size_t size_type;
typedef std::list<slot_base>::iterator iterator_type;
typedef std::list<slot_base>::const_iterator const_iterator_type;
signal_impl();
// 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()
{ ++ref_count_; }
/// Increments the reference and execution counter.
inline void reference_exec()
{ ++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
{ 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;
/** 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 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_);
/** 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 sweep() directly or defers the execution of
* sweep() when the signal is being emitted.
* @param d The signal object (@p this).
*/
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)
: 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(); }
};
} /* 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.
*
* 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 implicitely on connection, triggering compiler errors
* if the given functor or closure cannot be invoked with the
* parameter list of the signal to connect to.
*/
/** 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.
*
* @ingroup signal
*/
struct SIGC_API signal_base : public trackable
{
typedef size_t size_type;
signal_base();
signal_base(const signal_base& src);
~signal_base();
signal_base& operator = (const 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
{ 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;
protected:
typedef internal::signal_impl::iterator_type iterator_type;
/** 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 given position into the list of slots.
* @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_);
/** 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);
/** 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_ */

614
libs/sigc++2/sigc++/slot.h
View file

@ -1,614 +0,0 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_MACROS_SLOTHM4_
#define _SIGC_MACROS_SLOTHM4_
#include <sigc++/functors/slot.h>
#ifndef LIBSIGC_DISABLE_DEPRECATED
namespace SigC {
// SlotN
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot0 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 slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
template <class T_return>
class Slot0
: public ::sigc::slot<T_return>
{
public:
typedef ::sigc::slot<T_return> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot0(const parent_type& src)
: 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.
*/
Slot0& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot1 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()().
*
* To use simply assign the slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
template <class T_return, class T_arg1>
class Slot1
: public ::sigc::slot<T_return, T_arg1>
{
public:
typedef ::sigc::slot<T_return, T_arg1> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return, T_arg1>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot1(const parent_type& src)
: 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.
*/
Slot1& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot2 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()().
* - @e T_arg2 Argument type used in the definition of operator()().
*
* To use simply assign the slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2>
class Slot2
: public ::sigc::slot<T_return, T_arg1,T_arg2>
{
public:
typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot2(const parent_type& src)
: 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.
*/
Slot2& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot3 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()().
* - @e T_arg2 Argument type used in the definition of operator()().
* - @e T_arg3 Argument type used in the definition of operator()().
*
* To use simply assign the slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
class Slot3
: public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>
{
public:
typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot3(const parent_type& src)
: 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.
*/
Slot3& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot4 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()().
* - @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()().
*
* To use simply assign the slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
class Slot4
: public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
{
public:
typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot4(const parent_type& src)
: 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.
*/
Slot4& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot5 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()().
* - @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()().
*
* To use simply assign the slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
class Slot5
: public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
{
public:
typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot5(const parent_type& src)
: 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.
*/
Slot5& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot6 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()().
* - @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()().
*
* To use simply assign the slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
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 ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
{
public:
typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot6(const parent_type& src)
: 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.
*/
Slot6& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
/** Converts an arbitrary functor to a unified type which is opaque.
* Slot7 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()().
* - @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()().
*
* To use simply assign the slot to the desired functor. 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.
*
* @par Example:
* @code
* #include <sigc++/slot.h>
* void foo(int) {}
* SigC::Slot1<void, long> s = SigC::slot(&foo);
* s(19);
* @endcode
*
* @deprecated Use the unnumbered template sigc::slot instead.
* @ingroup compat
*/
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 ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
{
public:
typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type;
/// Constructs an empty slot.
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)
: ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {}
/** Constructs a slot, copying an existing one.
* @param src The existing slot to copy.
*/
Slot7(const parent_type& src)
: 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.
*/
Slot7& operator=(const parent_type& src)
{ parent_type::operator=(src); return *this; }
};
#ifndef DOXYGEN_SHOULD_SKIP_THIS
/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<>
* when "using namespace SigC" and later using a slot(obj,func) overload
* without the prefix "SigC::". Probably a compiler bug. I will investigate.
*
* This ugly hack avoids the error:
*/
// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */
#endif
// slot()
/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
template <class T_return>
inline Slot0<T_return>
slot(T_return (*_A_func)())
{ return Slot0<T_return>(_A_func); }
/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1>
inline Slot1<T_return, T_arg1>
slot(T_return (*_A_func)(T_arg1))
{ return Slot1<T_return, T_arg1>(_A_func); }
/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2>
inline Slot2<T_return, T_arg1,T_arg2>
slot(T_return (*_A_func)(T_arg1,T_arg2))
{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); }
/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3))
{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); }
/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4))
{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5))
{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); }
/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6))
{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); }
/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function.
*
* @param _A_func Pointer to function that should be wrapped.
* @return Functor that executes _A_func on invokation.
*
* @deprecated Use sigc::ptr_fun() instead.
* @ingroup compat
*/
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 Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7))
{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); }
}
#endif
#endif /* _SIGC_MACROS_SLOTHM4_ */

124
libs/sigc++2/sigc++/trackable.cc
View file

@ -1,124 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <sigc++/trackable.h>
#include <iostream>
using namespace std;
namespace sigc
{
trackable::trackable()
: callback_list_(0)
{}
/* 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*/)
: callback_list_(0)
{}
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()
{
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_ = 0;
}
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 (callback_list::iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
(*i).func_((*i).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 (callback_list::iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
(*i).func_((*i).data_);
callbacks_.clear();
clearing_ = false;
}
void trackable_callback_list::remove_callback(void* data)
{
if (clearing_) return; // No circular notices
for (callback_list::iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
if ((*i).data_ == data)
{
callbacks_.erase(i);
return;
}
}
} /* namespace internal */
} /* namespace sigc */

148
libs/sigc++2/sigc++/trackable.h
View file

@ -1,148 +0,0 @@
/*
* 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)
: 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) {}
/** 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
{
trackable();
trackable(const trackable& src);
trackable& operator=(const 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_ */

121
libs/sigc++2/sigc++/type_traits.h
View file

@ -1,121 +0,0 @@
/*
* 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++/reference_wrapper.h>
namespace sigc {
template <class T_type>
struct type_trait
{
typedef T_type type;
typedef T_type& pass;
typedef const T_type& take;
typedef T_type* pointer;
};
template <class T_type, int N>
struct type_trait<T_type[N]>
{
typedef T_type* type;
typedef T_type*& pass;
typedef const T_type*& take;
typedef T_type** pointer;
};
template <class T_type>
struct type_trait<T_type&>
{
typedef T_type type;
typedef T_type& pass;
typedef T_type& take;
typedef T_type* pointer;
};
template <class T_type>
struct type_trait<const T_type&>
{
typedef const T_type type;
typedef const T_type& pass;
typedef const T_type& take;
typedef const T_type* pointer;
};
template <class T_type>
struct type_trait<reference_wrapper<T_type> >
{
typedef T_type type;
typedef T_type& pass;
typedef T_type& take;
typedef T_type* pointer;
};
template <class T_type>
struct type_trait<const_reference_wrapper<T_type> >
{
typedef T_type type;
typedef T_type& pass;
typedef const T_type& take;
typedef T_type* pointer;
};
template<>
struct type_trait<void>
{
typedef void type;
typedef void pass;
typedef void take;
typedef void* pointer;
};
/** From Esa Pulkkin:
* Compile-time determination of base-class relationship in C++
* (adapted to match the syntax of boost's type_traits library).
*/
template <class T_base, class T_derived>
struct is_base_and_derived
{
private:
struct big {
char memory[64];
};
struct test {
static big is_base_class_(...);
static char is_base_class_(typename type_trait<T_base>::pointer);
};
public:
static const bool value =
sizeof(test::is_base_class_((typename type_trait<T_derived>::pointer)0)) ==
sizeof(char);
};
template <class T_base>
struct is_base_and_derived<T_base, T_base>
{
static const bool value = true;
};
} /* namespace sigc */
#endif /* _SIGC_TYPE_TRAIT_H_ */

128
libs/sigc++2/sigc++/visit_each.h
View file

@ -1,128 +0,0 @@
// -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _SIGC_VISIT_EACH_HPP_
#define _SIGC_VISIT_EACH_HPP_
#include <sigc++/type_traits.h>
namespace sigc {
namespace internal {
/// 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 <bool I_derived, class T_type> struct with_type;
template <class T_type> struct with_type<false,T_type>
{ static void execute_(const T_type&, const T_self&) {} };
template <class T_type> struct with_type<true,T_type>
{ static void execute_(const T_type& _A_type, const T_self& _A_action)
{ _A_action.action_(_A_type); }
};
template <class T_type>
void operator()(const T_type& _A_type) const
{ with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
limit_derived_target(const T_action& _A_action): action_(_A_action) {}
T_action action_;
};
/// Helper struct for visit_each_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 <bool I_derived, class T_type> struct with_type;
template <class T_type> struct with_type<false,T_type>
{ static void execute_(const T_type&, const T_self&) {} };
template <class T_type> struct with_type<true,T_type>
{ static void execute_(const T_type& _A_type, const T_self& _A_action)
{ _A_action.action_(&_A_type); }
};
template <class T_type>
void operator()(const T_type& _A_type) const
{ with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
limit_derived_target(const T_action& _A_action): action_(_A_action) {}
T_action action_;
};
} /* namespace internal */
/** This function performs a functor on each of the targets of a functor.
* All unknown types just call @e _A_action on them.
* Add overloads that specialize the @e 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
* struct some_functor
* {
* void operator()() {}
* some_possibly_sigc_trackable_derived_type some_data_member;
* some_other_functor_type some_other_functor;
* }
*
* namespace sigc
* {
* template <class T_action>
* void visit_each(const T_action& _A_action,
* const some_functor& _A_target)
* {
* visit_each(_A_action, _A_target.some_data_member);
* visit_each(_A_action, _A_target.some_other_functor);
* }
* }
* @endcode
*
* @ingroup functors
*/
template <class T_action, class T_functor>
void 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 limited to a restricted type.
*
* @ingroup functors
*/
template <class T_type, class T_action, class T_functor>
void visit_each_type(const T_action& _A_action, const T_functor& _A_functor)
{
internal::limit_derived_target<T_type,T_action> limited_action(_A_action);
visit_each(limited_action,_A_functor);
}
} /* namespace sigc */
#endif

10
libs/sigc++2/sigc++config.h.in
View file

@ -1,10 +0,0 @@
/* sigc++config.h.in. (Generated manually.) */
/* configure checks */
#undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
#undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
/* platform specific macros */
// #define LIBSIGC_DISABLE_DEPRECATED
// #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY // only defined for MSVC to keep ABI compatibility
#define SIGC_API