allanger/ardour
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Activity

Removed libglademm.

Browse Source 
Updated libsigc++ from 2.0.6 to 2.0.17.


git-svn-id: svn://localhost/ardour2/branches/2.1-staging@1413 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Taybin Rutkin
2007-02-03 02:13:18 +00:00
parent 8bde438b59
commit f76fc34c29
57 changed files with 3250 additions and 9614 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libs/libglademm/AUTHORS
View File

@@ -1,2 +0,0 @@
Maintainers:
Murray Cumming <murrayc@usa.net>

504
libs/libglademm/COPYING
View File

@@ -1,504 +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.
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.
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.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also 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.
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.
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.
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
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.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
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!

361
libs/libglademm/ChangeLog
View File

@@ -1,361 +0,0 @@
2.6.1:
2005-09-07 Murray Cumming <murrayc@murrayc.com>
* NEWS: Updated.
* configure.in: Increased version.
2005-03-10 Cedric Gustin <cedric.gustin@swing.be>
* MSVC_Net2003/Makefile.am: Add blank.cpp to EXTRA_DIST.
* MSVC_Net2003/libglademm/libglademm.vcproj: Disable warning #4250.
* MSVC_Net2003/examples/*/*.vcproj: Change name of
PDB file to $(OutDir)/$(TargetName).pdb. Disable warning #4250.
2.6.0:
2005-01-24 Cedric Gustin <cedric.gustin@swing.be>
* MSVC_Net2003/libglademm/Makefile.am: Rewrote rule for local copy
of glibmmconfig.h (required for 'make distcheck').
* MSVC_Net2003/libglademm/libglademm.vcproj: Removed GLIBMM_BUILD
macro.
2.5.1:
2005-01-11 Murray Cumming <murrayc@murrayc.com>
* MSVC_Net2003/libglademm/Makefile.am: Add libglademmconfig.h to
DISTCLEANFILES, to fix the distcheck.
2004-12-13 Cedric Gustin <cedric.gustin@swing.be>
* configure.in : parse version tags at configure time (for
libglademm-2.4.rc).
* MSVC_Net2003/libglademm/libglademm-2.4.rc.in : New resource file.
* MSVC_Net2003/libglademm/Makefile.am: Include libglademm-2.4.rc
in distribution.
* MSVC_Net2003/libglademm/libglademm.vcproj: Added resource file.
2004-12-08 Cedric Gustin <cedric.gustin@swing.be>
* MSVC_Net2003/: Initial release.
* configure.in: Added MSVC_Net2003 Makefiles.
* Makefile.am: Added MSVC_Net2003 subdir.
2004-08-28 Alberto Paro <alberto@paro.homeunix.org>
* libglade/xml.{ccg|hg}: Added connect_clicked() for easy connection of
buttons and menuitems signals to a signal handler.
* libglade/variablesmap.[ccg|hg]: Glade::VariablesMap now handles
Entry, ComboTextEntry, SpinButton, *Scale, Calendar and CheckBox.
* example/variablesmap: Improved the example to handle new
VariablesMap types.
2004-09-19 Murray Cumming <murrayc@murrayc.com>
* This is the HEAD branch.
2004-09-19 Murray Cumming <murrayc@murrayc.com>
* libglademm/xml.hg: Fix from Denis Leroy in bug #151872.
2.4.1:
2004-06-02 Bryan Forbes <bryan@reigndropsfall.net>
* examples/derived/deriveddialog.h: fix to compile with gcc 3.4.0.
2.4.0:
2.3.3:
2004-03-28 <jdhall@uiuc.edu>
* libglade/xml.hg: Check the return value of get_cwidget().
2004-03-18 Murray Cumming <murrayc@murrayc.com>
* docs/reference/Makefile.am: Removed make target dependency on
installed beautify_docs, so it does not try to rebuild them when
building from a tarball. Bug #137548 from Dalgoda.
2004-03-15 Cedric Gustin <cedric.gustin@swing.be>
* tools/m4/Makefile.am: install m4 files in libglademm-2.4 subdir
instead of libglademm-2.0.
2004-03-15 Cedric Gustin <cedric.gustin@swing.be>
* configure.in: Added test for struct packing convention on win32
(-mms-bitfields / -fnative-struct).
2004-03-12 Murray Cumming <murrayc@murrayc.com>
* libglade/src/xml.hg: get_widget_derived(): actually return the
existing widget when a wrapper instance already exists. Bug #136913
from Roger Whinlatter who submitted it to debian but should have
submitted it to bugzilla.gnome.org first.
2.3.2:
2004-02-13 Murray Cumming <murrayc@murrayc.com>
* Updated for latest libsigc++ 2 API.
2.3.1:
2003-12-31 Murray Cumming <murrayc@usa.net>
* docs/reference/Makefile.am: Generate a real devhelp file. Added
a doxygen_to_devhelp.xsl file for this, by copying it from gtkmm and
modifying it.
2003-12-29 Murray Cumming <murrayc@usa.net>
* configure.in: Use glibmm_check_perl() m4 macro installed by glibmm,
so that doxygen can know the PERL_PATH.
* docs/reference/Makefile.am: Added the docs rules from the same
file in gtkmm, so that the docs are built and distributed and installed
and uploaded.
2003-12-22 Murray Cumming <murrayc@usa.net>
* docs/reference/Makefile.am: Use beautify_docs.pl installed from
glibmm 2.4.
2.3.0:
2003-12-07 Murray Cumming <murrayc@usa.net>
* examples/menus/example.glade: Corrected the text. Patch by
Billy O'Connor in bug 128683.
2003-11-29 Murray Cumming <murrayc@usa.net>
* libglade/libglade-2.0.pc.in: Corrected library name.
2003-11-06 Cedric Gustin <cedric.gustin@swing.be>
* configure.in: Added test of win32 platform. Commented
out AM_DISABLE_SHARED (DLLs are shared libraries).
* build_shared/Makefile_build.am_fragment: added a few LDFLAGS
for win32 DLLs (defined in win32_dlls_ldflags and appended to
common_ldflags).
2003-11-06 Murray Cumming <murrayc@usa.net>
* Added examples/menus.
* examples/basic: Added and distributed basic.gladep which is
necessary to prevent glade-2 from creating libgnomeui menus.
2003-11-02 Murray Cumming <murrayc@usa.net>
* This is now libglademm 2.4, which builds against gtkmm 2.4, and is
parallel-installable with libglademm 2.0/2.2.
This is HEAD, for GNOME 2.6, using gtkmm 2.4.
2003-10-30 Murray Cumming <murrayc@usa.net>
* libglade/libglademm.h: Include gtkmmconfig.h rather than
libgnomemmconfig.h. These are platform-specific stuff. I am
surprised that it built before, because this does not depend
on libgnomemm at all.
2003-10-17 Alberto Paro <alberto@paro.homeunix.org>
* docs/reference/Doxyfile.in: fixed docs generation
2.1.2:
2003-09-25 Eric Bourque <ericb@computer.org>
* libglademm.spec.in: new file
2003-09-02 Murray Cumming <murrayc@usa.net>
* libglademm/src/xml.hg: Added code to get_widget_derived(),
to return an existing C++ instance if one exists. This makes
get_widget_derived() always return the same instance, like
get_widget() already does. I added some more explicit explanation
to the gtkmm book about this.
2.1.1:
2003-09-01 Murray Cumming <murrayc@usa.net>
* Just rebuilt the tarball. Some corruption was causing the
.la files to not be installed.
2.1.0:
2003-08-23 Murray Cumming <murrayc@usa.net>
* libglademm/src/xml.[hg|ccg]: Added
Glade::Xml::get_widget_derived() templated method.
* Added examples/derived/ to demonstrate it. This allows you
to encapsulate the handling of the child widgets inside the
container widget's code.
* Makefile.am: Added examples to SUBDIRS so that they are built
by default, for regression testing.
* examples/Makefile.am_fragment: Added top_srcdir include for
distcheck.
2.0.0:
2002-12-20 Daniel Elstner <daniel.elstner@gmx.net>
* examples/basic/basic.cc (main): Exit the program if loading
the glade file failed, so that it won't segfault.
2002-12-20 Murray Cumming <murrayc@usa.net>
* _IGNORE()ed some internal libglade functions.
2002-12-20 Murray Cumming <murrayc@usa.net>
* examples/basic/basic.cc: Used try/catch to catch the new XmlError
exception. Added some comments.
2002-12-20 Daniel Elstner <daniel.elstner@gmx.net>
* libglade/src/xml.{ccg,hg} (XmlError): New exception class.
(Xml::Xml): Throw an XmlError exception if glade_xml_construct()
or glade_xml_create_from_buffer() failed.
2002-12-16 Daniel Elstner <daniel.elstner@gmx.net>
* libglade/src/xml.{ccg,hg} (Xml::Xml): In order to reduce code
size, replace the ctor overloads with a single ctor and default
arguments, and treat empty strings as 0. Also, use std::string
instead of Glib::ustring for the filename argument.
(Xml::Xml): Add ctor overload for glade_xml_new_from_buffer().
We should use a construct() function instead but that requires
an API addition to libglade.
(Xml::create): Use std::string for the filename argument, and
reduce code by using default arguments instead of 3 overloads.
(Xml::create_from_buffer): Take a plain const char* for the buffer
argument, plus an int for its size. We already need to do this
for the ctor to avoid overload ambiguities, and I don't see much
of a point in providing an additional create_from_buffer() overload
since it's rarely used.
(Xml::get_widget_checked): New internal method that checks the
type of the widget and prints a warning on failure.
(Xml::get_widget): Move most of the code into the non-templated
method get_widget_checked(), to reduce binary size.
(Xml::relative_file): Take and return std::string, since it's
a filename.
(Xml::get_filename): New accessor to public struct data member.
(Xml::get_widget_name): Add.
(Xml::glade_get_widget_tree): Add.
* tools/m4/convert_libglademm.m4: Add conversion from GladeXML*
to Glib::RefPtr<Xml>.
2002-12-16 Murray Cumming <murrayc@usa.net>
* src/xml.hg: reparent_widget() is no longer virtual.
2002-12-16 Murray Cumming <murrayc@usa.net>
* src/xml.[hg|ccg]: Renamed lookup_type() to lookup_type_vfunc(), to
be consistent with other gtkmm vfuncs, and made it virtual.
2002-12-12 Murray Cumming <murrayc@usa.net>
* configure.in: Increased version from 1.3.x to 2.0
* libglademm/libglademm/Makefile.am: Changed librarary name.
* libglademm/*.pc.in: Changed library name.
* examples/Makefile.am_fragment: Changed library name.
2002-12-10 Bradley Bell <btb@debian.org>
* scripts/Makefile.am: distribute macros.m4
1.3.5:
* Updated for gtkmm2.
1.3.4:
2002-08-07 Murray Cumming <murrayc@usa.net>
* Glade::Xml now uses the new gtkmm _CONSTRUCT macro, so it uses
the correct Glib::Object constructor.
2002-08-06 Martin Schulze <MHL.Schulze@t-online.de>
* examples/basic/Makefile.am: Replace 'example' with 'basic' to
match the actual file names.
1.3.3:
2002-07-16 Murray Cumming <murrayc@usa.net>
* Rebuilt for latest gtkmm.
1.3.2:
2002-06-23 Murray Cumming <murrayc@usa.net>
* Rebuilt for latest gtkmm.
* VariablesMap: Fixed "no return statement" warning.
1.3.1:
2002-05-02 Murray Cumming <murrayc@usa.net>
* Added Gnome::Glade::VariablesMap, with an example. This allows
you to map named Glade widgets to member variables, and transfer
all the data with one method call.
1.3.0:
2002-04-29 Murray Cumming <murrayc@usa.net>
* Added reparent_widget() method.
2002-04-28 Murray Cumming <murrayc@usa.net>
* Added templated get_widget(name, widget) override, which
does the dynamic casting and warns about any runtime errors, so
that application code doesn't need to.
2002-04-25 Murray Cumming <murrayc@usa.net>
* examples/basic: Use a GtkDialog in the .glade file instead of
the deprecated GnomeDialog. The signal connection now seems to
work.
* libglade/src/xml.[hg|ccg]: Added a lookup_type() vfunc
that instantiates gtkmm types instead of gtk+ types. This requires
the latest libglade.
2002-04-25 Michael A. Koziarski <michael@koziarski.org>
* libglade/src/xml.ccg
* libglade/src/xml.hg: As requested, implemented overloaded
create_from_buffer methods.
2002-04-25 Murray Cumming <murrayc@usa.net>
* Added "basic" example based on the libglade docs and Michael
Koziarski's .glade file.
2002-04-24 Michael A. Koziarski <michael@koziarski.org>
* libglade/src/xml.ccg
* libglade/src/xml.hg: Implemented overloaded create methods &
constructors. Most applications won't need to send a domain
parameter, and some don't need a root parameter
2002-04-23 Murray Cumming <murrayc@usa.net>
* Generated sources are now distributed. The
build_shared/*.am_fragement files were copied from libgnomecanvasmm.
2002-04-23 Murray Cumming <murrayc@usa.net>
* Xml constructor uses the glade_xml_construct() function because
GladeXML doesn't have construct-time properties yet.

95
libs/libglademm/NEWS
View File

@@ -1,95 +0,0 @@
2.6.1:
* Windows build fixes. (Cedric Gustin)
2.6.0:
libglademm 2.6 is API/ABI-compatible with libglademm 2.4.
Changes since libglademm 2.4:
* Glade::Xml: Added connect_clicked() for easy connection of
buttons and menuitems signals. (Alberto Paro)
* Glade::VariablesMap: now handles Entry, ComboTextEntry,
SpinButton, *Scale, Calendar and CheckBox. (Alberto Paro).
2.5.1:
* Glade::Xml: Added connect_clicked() for easy connection of
buttons and menuitems signals. (Alberto Paro)
* Glade::VariablesMap: now handles Entry, ComboTextEntry,
SpinButton, *Scale, Calendar and CheckBox. (Alberto Paro).
2.4.1:
* gcc 3.4 build fix. (Bryan Forbes)
2.4.0:
The API is now stable.
2.3.3:
* get_widget():
- Don't create a C++ object with a null C object, when the
C object can not be found. (jdhall)
- Really return existing widget wrappers. (Murray Cumming)
* Stop accidental need for doxygen when building from tarballs.
(Murray Cumming)
* win32: Test for -mms-bitfields / -fnative-struct.
2.3.2:
* Updated for new libsigc++ 2 syntax.
2.3.1:
Documentation:
- Generate and install devhelp file.
- beautify hmtl documentation, like the gtkmm docs.
- Install html documentation.
2.3.0:
This is the new unstable branch of the parallel-installable libglademm 2.4,
for use with gtkmm 2.4.
2.1.2:
* get_widget_derived() now returns an existing C++ instance if one exists, like
get_widget() already does. (Murray Cumming)
2.1.1:
No changes. Just recreated the tarball - it was not installing the .la files.
2.1.0:
This is the development phase for libglademm 2.2.0,
which will add API but will not break API or ABI.
* Added Glade::Xml::get_widget_derived() and
examples/derived/ to demonstrate it.
This allows you to use Glade to layout your
own derived container widgets. Tell me what you
think.
(Murray Cumming)
2.0.1:
* Rebuilt the tarball with newer autotools, fixing the $SED problem.
2.0.0
* Glade::Xml::create() now throws an XmlError expection if it fails.
(Daniel Elstner)
* Minimise use of templates, to reduce application code size.
(Daniel Elstner)
1.3.5

25
libs/libglademm/SConscript
View File

@@ -1,25 +0,0 @@
# -*- python -*-
import os
import os.path
import glob
Import('env libraries install_prefix')
libglademm_files = glob.glob('libglademm/*.cc')
libglademm = env.Copy()
libglademm.Merge([libraries['gtk2'], libraries['glade2'], libraries['sigc2'], libraries['glibmm2'], libraries['pangomm'], libraries['atkmm'], libraries['gdkmm2'], libraries['gtkmm2']])
libglade = libglademm.SharedLibrary('libglademm', libglademm_files)
Default(libglade)
env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2'), libglade))
env.Alias('tarball', env.Distribute (env['DISTTREE'],
[ 'SConscript', 'libglademmconfig.h', 'libglademm.h'] +
libglademm_files +
glob.glob('libglademm/*.h') +
glob.glob('libglademm/private/*.h')
))

31
libs/libglademm/libglademm.h
View File

@@ -1,31 +0,0 @@
/* $Id$ */
/* libglademm - a C++ wrapper for libglade
*
* Copyright 1999-2001 Free Software Foundation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef LIBGLADEMM_H
#define LIBGLADEMM_H
/* libglademm version. */
extern const int libglademm_major_version;
extern const int libglademm_minor_version;
extern const int libglademm_micro_version;
#include <libglademm/xml.h>
#endif /* #ifndef LIBGLADEMM_H */

34
libs/libglademm/libglademm/init.cc
View File

@@ -1,34 +0,0 @@
// -*- c++ -*-
/* $Id$ */
/* init.cc
*
* Copyright 2001 Free Software Foundation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <libglademm/init.h>
#include <libglademm/wrap_init.h>
namespace Gnome
{
namespace Glade
{
} //namespace Glade
} //namespace Gnome

38
libs/libglademm/libglademm/init.h
View File

@@ -1,38 +0,0 @@
// -*- c++ -*-
#ifndef _LIBGLADEMM_INIT_H
#define _LIBGLADEMM_INIT_H
/* $Id$ */
/* init.h
*
* Copyright 2001 Free Software Foundation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
namespace Gnome
{
namespace Glade
{
} /* namespace Glade */
} //namespace Gnome
#endif //_LIBGLADEMM_INIT_H

50
libs/libglademm/libglademm/private/xml_p.h
View File

@@ -1,50 +0,0 @@
// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _LIBGLADEMM_XML_P_H
#define _LIBGLADEMM_XML_P_H
#include <glibmm/private/object_p.h>
#include <glibmm/class.h>
namespace Gnome
{
namespace Glade
{
class Xml_Class : public Glib::Class
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef Xml CppObjectType;
typedef GladeXML BaseObjectType;
typedef GladeXMLClass BaseClassType;
typedef Glib::Object_Class CppClassParent;
typedef GObjectClass BaseClassParent;
friend class Xml;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
const Glib::Class& init();
static void class_init_function(void* g_class, void* class_data);
static Glib::ObjectBase* wrap_new(GObject*);
protected:
//Callbacks (default signal handlers):
//These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
//You could prevent the original default signal handlers being called by overriding the *_impl method.
//Callbacks (virtual functions):
static GType lookup_type_vfunc_callback(GladeXML* self, const char* classname);
};
} // namespace Glade
} // namespace Gnome
#endif /* _LIBGLADEMM_XML_P_H */

199
libs/libglademm/libglademm/variablesmap.cc
View File

@@ -1,199 +0,0 @@
/* variablesmap.cc
*
* Copyright (C) 2002 The libglademm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <libglademm/variablesmap.h>
#include <gtkmm/togglebutton.h>
#include <gtkmm/entry.h>
#include <gtkmm/calendar.h>
#include <gtkmm/scale.h>
#include <gtkmm/comboboxentry.h>
namespace Gnome
{
namespace Glade
{
VariablesMap::VariablesMap(const Glib::RefPtr<Glade::Xml>& glade)
: m_refGlade(glade)
{
}
VariablesMap::~VariablesMap()
{
}
void VariablesMap::connect_widget(const Glib::ustring& widget_name, bool& variable)
{
Gtk::ToggleButton* pToggleButton = 0;
m_refGlade->get_widget(widget_name, pToggleButton); //Glade::Xml will complain if it is not a ToggleButton.
if(pToggleButton)
{
m_mapWidgetsToVariables[pToggleButton] = (void*)(&variable);
}
}
void VariablesMap::connect_widget(const Glib::ustring& widget_name, Glib::ustring& variable)
{
Gtk::Widget* pWidget = 0;
m_refGlade->get_widget(widget_name, pWidget);
Gtk::Entry* pEntry = dynamic_cast<Gtk::Entry*>(pWidget); //it mange both Gtk::entry and Gtk::SpinButton
Gtk::ComboBoxEntry* pComboBoxEntry = dynamic_cast<Gtk::ComboBoxEntry*>(pWidget);
if(pEntry)
{
m_mapWidgetsToVariables[pEntry] = (void*)(&variable);
}
if(pComboBoxEntry)
{
m_mapWidgetsToVariables[pComboBoxEntry] = (void*)(&variable);
}
}
void VariablesMap::connect_widget(const Glib::ustring& widget_name, double& variable)
{
Gtk::Widget* pWidget = 0;
m_refGlade->get_widget(widget_name, pWidget);
Gtk::Scale* pScale = dynamic_cast<Gtk::Scale*>(pWidget);
if(pScale)
{
m_mapWidgetsToVariables[pScale] = (void*)(&variable);
}
}
void VariablesMap::connect_widget(const Glib::ustring& widget_name, Glib::Date& variable)
{
Gtk::Widget* pWidget = 0;
m_refGlade->get_widget(widget_name, pWidget);
Gtk::Calendar* pCalendar = dynamic_cast<Gtk::Calendar*>(pWidget);
if(pCalendar)
{
m_mapWidgetsToVariables[pCalendar] = (void*)(&variable);
}
}
void VariablesMap::transfer_widgets_to_variables()
{
if(validate_widgets()) //If the widgets' data is correct. Useful to override.
{
for(type_mapWidgetsToVariables::iterator iter = m_mapWidgetsToVariables.begin(); iter != m_mapWidgetsToVariables.end(); ++iter)
{
transfer_one_widget(iter->first, true); //true = to_variable.
}
}
}
void VariablesMap::transfer_variables_to_widgets()
{
for(type_mapWidgetsToVariables::iterator iter = m_mapWidgetsToVariables.begin(); iter != m_mapWidgetsToVariables.end(); ++iter)
{
transfer_one_widget(iter->first, false); //false = to_widget.
}
}
void VariablesMap::transfer_one_widget(Gtk::Widget* pWidget, bool to_variable)
{
//Find the widget in the map:
type_mapWidgetsToVariables::iterator iterFind = m_mapWidgetsToVariables.find(pWidget);
if(iterFind != m_mapWidgetsToVariables.end())
{
//Get the variable for the widget:
void* pVariable = iterFind->second;
if(pVariable)
{
//Cast the variable appropriately and set it appropriately:
Gtk::Entry* pEntry = dynamic_cast<Gtk::Entry*>(pWidget);
Gtk::ComboBoxEntry* pComboBoxEntry = dynamic_cast<Gtk::ComboBoxEntry*>(pWidget);
Gtk::ToggleButton* pToggleButton = dynamic_cast<Gtk::ToggleButton*>(pWidget); //CheckButtons and RadioButtons.
Gtk::Scale* pScale = dynamic_cast<Gtk::Scale*>(pWidget);
Gtk::Calendar* pCalendar = dynamic_cast<Gtk::Calendar*>(pWidget);
if(pEntry)
{
Glib::ustring* pVar = (Glib::ustring*)(pVariable);
if(to_variable)
(*pVar) = pEntry->get_text();
else
pEntry->set_text(*pVar);
}
if(pComboBoxEntry)
{
Glib::ustring* pVar = (Glib::ustring*)(pVariable);
Gtk::Entry* pIEntry = dynamic_cast<Gtk::Entry*>(pComboBoxEntry->get_child());
if(to_variable){
if(pIEntry)
(*pVar) = pIEntry->get_text();
} else {
if(pIEntry)
pIEntry->set_text(*pVar);
}
}
if(pToggleButton)
{
bool* pVar = (bool*)(pVariable);
if(to_variable)
(*pVar) = pToggleButton->get_active();
else
pToggleButton->set_active(*pVar);
}
if(pScale)
{
double* pVar = (double*)(pVariable);
if(to_variable)
(*pVar) = pScale->get_value();
else
pScale->set_value(*pVar);
}
if(pCalendar)
{
Glib::Date* pVar = (Glib::Date*)(pVariable);
if(to_variable){
guint year,month,day;
pCalendar->get_date(year,month,day);
(*pVar) = Glib::Date(day,(Glib::Date::Month)month,year);
} else {
pCalendar->select_day(pVar->get_day());
pCalendar->select_month(pVar->get_month(), pVar->get_year());
}
}
}
}
}
bool VariablesMap::validate_widgets()
{
//Override to add validation.
//TODO: We could add some automatic data-range and text-length validation.
return true;
}
} /* namespace Glade */
} /* namespace Gnome */

96
libs/libglademm/libglademm/variablesmap.h
View File

@@ -1,96 +0,0 @@
/* variablesmap.h
*
* Copyright (C) 2002 The libglademm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef _LIBGLADEMM_VARIABLESMAP_H
#define _LIBGLADEMM_VARIABLESMAP_H
#include <libglademm/xml.h>
#include <map>
namespace Gnome
{
namespace Glade
{
/** Associates named Glade widgets with member variables.
* Use connect_widget() to link the widgets with variables that will contain their data.
* Then use transfer_widgets_to_variables() and transfer_variables_to_widgets() to get or set all of the variables at once.
*
* This is meant to be a bit like MFC's "Dialog Data Exchange and Validation".
*
* The association of widget and member varables follow this mapping:
*
* Gtk::Entry --> Glib::ustring
* Gtk::SpinBox --> Glib::ustring
* Gtk::ComboBoxEntry --> Glib::ustring
* Gtk::Scale --> double
* Gtk::Calendar --> Glib::Date
* Gtk::CheckBox --> bool
* Gtk::RadioButton --> bool
*
*/
class VariablesMap
{
public:
explicit VariablesMap(const Glib::RefPtr<Glade::Xml>& glade);
virtual ~VariablesMap();
///For ToggleButton (CheckBox and RadioButton)
virtual void connect_widget(const Glib::ustring& widget_name, bool& variable);
///For Entry, ComboBoxEntry and SpinBox
virtual void connect_widget(const Glib::ustring& widget_name, Glib::ustring& variable);
///For Scale (HScale and VScale)
virtual void connect_widget(const Glib::ustring& widget_name, double& variable);
///For Calendar
virtual void connect_widget(const Glib::ustring& widget_name, Glib::Date& variable);
///Transfer data from the widget to the variable.
virtual void transfer_widgets_to_variables();
///Transfer data from the variable to the widget.
virtual void transfer_variables_to_widgets();
protected:
/** Override this to validate the data that the user enters into the widgets.
* The return value indicates whether the widgets' data is valid.
*/
virtual bool validate_widgets();
virtual void transfer_one_widget(Gtk::Widget* pWidget, bool to_variable);
typedef std::map<Gtk::Widget*, void*> type_mapWidgetsToVariables;
type_mapWidgetsToVariables m_mapWidgetsToVariables;
Glib::RefPtr<Glade::Xml> m_refGlade;
};
} /* namespace Glade */
} /* namespace Gnome */
#endif /* _LIBGLADEMM_VARIABLESMAP_H */

50
libs/libglademm/libglademm/wrap_init.cc
View File

@@ -1,50 +0,0 @@
#include <glib.h>
// Disable the 'const' function attribute of the get_type() functions.
// GCC would optimize them out because we don't use the return value.
#undef G_GNUC_CONST
#define G_GNUC_CONST /* empty */
#include <libglademm/wrap_init.h>
#include <glibmm/error.h>
#include <glibmm/object.h>
// #include the widget headers so that we can call the get_type() static methods:
#include "xml.h"
extern "C"
{
//Declarations of the *_get_type() functions:
GType glade_xml_get_type(void);
//Declarations of the *_error_quark() functions:
} // extern "C"
//Declarations of the *_Class::wrap_new() methods, instead of including all the private headers:
namespace Gnome { namespace Glade { class Xml_Class { public: static Glib::ObjectBase* wrap_new(GObject*); }; } }
namespace Gnome { namespace Glade {
void wrap_init()
{
// Register Error domains:
// Map gtypes to gtkmm wrapper-creation functions:
Glib::wrap_register(glade_xml_get_type(), &Gnome::Glade::Xml_Class::wrap_new);
// Register the gtkmm gtypes:
Gnome::Glade::Xml::get_type();
} // wrap_init()
} //Glade
} //Gnome

37
libs/libglademm/libglademm/wrap_init.h
View File

@@ -1,37 +0,0 @@
#ifndef _LIBGLADEMM_WRAP_INIT_H
#define _LIBGLADEMM_WRAP_INIT_H
/* wrap_init.h
*
* Copyright (C) 1998-2001 The libglademm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
// wrap_init.cc is generated by tools/generate_wrap_init.pl
namespace Gnome
{
namespace UI
{
void wrap_init();
} /* namespace UI */
} /* namespace Gnome */
#endif // _LIBGLADEMM_WRAP_INIT_H

343
libs/libglademm/libglademm/xml.cc
View File

@@ -1,343 +0,0 @@
// Generated by gtkmmproc -- DO NOT MODIFY!
#include <libglademm/xml.h>
#include <libglademm/private/xml_p.h>
/* $Id$ */
/* Copyright (C) 2002 The libglademm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <glade/glade-xml.h>
#include <gtkmm/button.h>
#include <gtkmm/menuitem.h>
namespace Gnome
{
namespace Glade
{
XmlError::XmlError(const Glib::ustring& message)
:
message_ (message)
{}
XmlError::~XmlError() throw()
{}
XmlError::XmlError(const XmlError& other)
:
Glib::Exception (other),
message_ (other.message_)
{}
XmlError& XmlError::operator=(const XmlError& other)
{
message_ = other.message_;
return *this;
}
Glib::ustring XmlError::what() const
{
return message_;
}
Xml::Xml(const std::string& filename, const Glib::ustring& root, const Glib::ustring& domain)
:
Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
Glib::Object(Glib::ConstructParams(xml_class_.init(), (char*) 0))
{
if(!glade_xml_construct(gobj(), filename.c_str(), root.empty() ? 0 : root.c_str(),
domain.empty() ? 0 : domain.c_str()))
{
throw XmlError("Failed to load glade file `" + Glib::filename_to_utf8(filename) + '\'');
}
}
// TODO: we need glade_xml_construct_from_buffer()
Xml::Xml(const char* buffer, int size, const Glib::ustring& root, const Glib::ustring& domain)
:
Glib::ObjectBase(0),
Glib::Object((GObject*) glade_xml_new_from_buffer(
buffer, size, root.empty() ? 0 : root.c_str(), domain.empty() ? 0 : domain.c_str()))
{
if(!gobj())
throw XmlError("Failed to read glade input buffer");
}
// static
Glib::RefPtr<Xml> Xml::create(const std::string& filename,
const Glib::ustring& root, const Glib::ustring& domain)
{
return Glib::RefPtr<Xml>(new Xml(filename, root, domain));
}
// static
Glib::RefPtr<Xml> Xml::create_from_buffer(const char* buffer, int size,
const Glib::ustring& root, const Glib::ustring& domain)
{
return Glib::RefPtr<Xml>(new Xml(buffer, size, root, domain));
}
void Xml::reparent_widget(const Glib::ustring& name, Gtk::Container& container)
{
Gtk::Widget* pWidget = 0;
get_widget(name, pWidget);
g_return_if_fail(pWidget != 0);
pWidget->reparent(container);
}
Gtk::Widget* Xml::get_widget_checked(const Glib::ustring& name, GType type)
{
// Get the widget from the glade file.
Gtk::Widget *const pWidget = get_widget(name);
if(!pWidget)
{
g_critical("widget `%s' not found in glade file `%s'", name.c_str(), gobj()->filename);
return 0;
}
// Check if it has the correct type.
if(!g_type_is_a(G_OBJECT_TYPE(pWidget->gobj()), type))
{
g_critical("widget `%s' (in glade file `%s') is of type `%s' but `%s' was expected",
name.c_str(), gobj()->filename, G_OBJECT_TYPE_NAME(pWidget->gobj()), g_type_name(type));
return 0;
}
return pWidget;
}
GtkWidget* Xml::get_cwidget(const Glib::ustring& name)
{
GtkWidget* pCWidget = glade_xml_get_widget(gobj(), name.c_str());
if(!pCWidget)
g_critical("Glade::Xml::get_cwidget(): glade_xml_get_widget() failed.");
return pCWidget;
}
// Custom coded so that we can custom-code the vfunc in the Xml class.
// This is marginally better than modifying gtkmmproc to allow this.
//
GType Xml_Class::lookup_type_vfunc_callback(GladeXML* self, const char* classname)
{
CppObjectType *const obj = dynamic_cast<CppObjectType*>(
Glib::ObjectBase::_get_current_wrapper((GObject*) self));
if(obj)
{
try
{
return obj->lookup_type_vfunc(Glib::convert_const_gchar_ptr_to_ustring(classname));
}
catch(...)
{
Glib::exception_handlers_invoke();
}
}
else
{
BaseClassType *const base = static_cast<BaseClassType*>(
g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class.
);
if(base && base->lookup_type)
return (*base->lookup_type)(self, classname);
}
return 0;
}
GType Xml::lookup_type_vfunc(const Glib::ustring& classname)
{
// See if there is a gtkmm version of the gclass:
Glib::ustring classname_prefixed ("gtkmm__"); // gtkmm uses a prefix
classname_prefixed += classname;
GType gtype = g_type_from_name(classname_prefixed.c_str());
if(gtype == G_TYPE_INVALID) // if it's not a registered typename
{
// There's no gtkmm derived type, so just use the normal one.
gtype = g_type_from_name(classname.c_str());
}
return gtype;
}
void Xml::connect_clicked(const Glib::ustring& widget_name, const sigc::slot<void>& slot_ )
{
Gtk::Widget* pWidget = 0;
get_widget(widget_name, pWidget);
Gtk::Button* pButton = dynamic_cast<Gtk::Button*>(pWidget);
Gtk::MenuItem* pMenuItem = dynamic_cast<Gtk::MenuItem*>(pWidget);
if(pButton)
pButton->signal_clicked().connect( slot_);
if(pMenuItem)
pMenuItem->signal_activate().connect( slot_ );
}
} // namespace Glade
} // namespace Gnome
namespace
{
} // anonymous namespace
namespace Glib
{
Glib::RefPtr<Gnome::Glade::Xml> wrap(GladeXML* object, bool take_copy)
{
return Glib::RefPtr<Gnome::Glade::Xml>( dynamic_cast<Gnome::Glade::Xml*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
//We use dynamic_cast<> in case of multiple inheritance.
}
} /* namespace Glib */
namespace Gnome
{
namespace Glade
{
/* The *_Class implementation: */
const Glib::Class& Xml_Class::init()
{
if(!gtype_) // create the GType if necessary
{
// Glib::Class has to know the class init function to clone custom types.
class_init_func_ = &Xml_Class::class_init_function;
// This is actually just optimized away, apparently with no harm.
// Make sure that the parent type has been created.
//CppClassParent::CppObjectType::get_type();
// Create the wrapper type, with the same class/instance size as the base type.
register_derived_type(glade_xml_get_type());
// Add derived versions of interfaces, if the C type implements any interfaces:
}
return *this;
}
void Xml_Class::class_init_function(void* g_class, void* class_data)
{
BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
CppClassParent::class_init_function(klass, class_data);
klass->lookup_type = &lookup_type_vfunc_callback;
}
Glib::ObjectBase* Xml_Class::wrap_new(GObject* object)
{
return new Xml((GladeXML*)object);
}
/* The implementation: */
GladeXML* Xml::gobj_copy()
{
reference();
return gobj();
}
Xml::Xml(const Glib::ConstructParams& construct_params)
:
Glib::Object(construct_params)
{}
Xml::Xml(GladeXML* castitem)
:
Glib::Object((GObject*)(castitem))
{}
Xml::~Xml()
{}
Xml::CppClassType Xml::xml_class_; // initialize static member
GType Xml::get_type()
{
return xml_class_.init().get_type();
}
GType Xml::get_base_type()
{
return glade_xml_get_type();
}
std::string Xml::get_filename() const
{
return Glib::convert_const_gchar_ptr_to_stdstring(gobj()->filename);
}
Gtk::Widget* Xml::get_widget(const Glib::ustring& name)
{
return Glib::wrap(glade_xml_get_widget(gobj(), name.c_str()));
}
Glib::ListHandle<Gtk::Widget*> Xml::get_widget_prefix(const Glib::ustring& name)
{
return Glib::ListHandle<Gtk::Widget*>(glade_xml_get_widget_prefix(gobj(), name.c_str()), Glib::OWNERSHIP_SHALLOW);
}
std::string Xml::relative_file(const std::string& filename) const
{
return Glib::convert_return_gchar_ptr_to_stdstring(glade_xml_relative_file(const_cast<GladeXML*>(gobj()), filename.c_str()));
}
Glib::ustring Xml::get_widget_name(Gtk::Widget& widget)
{
return Glib::convert_const_gchar_ptr_to_ustring(glade_get_widget_name((widget).gobj()));
}
Glib::RefPtr<Xml> Xml::get_widget_tree(Gtk::Widget& widget)
{
Glib::RefPtr<Xml> retvalue = Glib::wrap(glade_get_widget_tree((widget).gobj()));
if(retvalue)
retvalue->reference(); //The function does not do a ref for us.
return retvalue;
}
} // namespace Glade
} // namespace Gnome

348
libs/libglademm/libglademm/xml.h
View File

@@ -1,348 +0,0 @@
// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _LIBGLADEMM_XML_H
#define _LIBGLADEMM_XML_H
#include <glibmm.h>
/* $Id$ */
/* Copyright (C) 2002 The libglademm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <gtkmm/container.h>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GladeXML GladeXML;
typedef struct _GladeXMLClass GladeXMLClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
namespace Gnome
{
namespace Glade
{ class Xml_Class; } // namespace Glade
} // namespace Gnome
namespace Gnome
{
namespace Glade
{
class XmlError : public Glib::Exception
{
public:
explicit XmlError(const Glib::ustring& message);
virtual ~XmlError() throw();
XmlError(const XmlError& other);
XmlError& operator=(const XmlError& other);
virtual Glib::ustring what() const;
private:
Glib::ustring message_;
};
class Xml : public Glib::Object
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
public:
typedef Xml CppObjectType;
typedef Xml_Class CppClassType;
typedef GladeXML BaseObjectType;
typedef GladeXMLClass BaseClassType;
private: friend class Xml_Class;
static CppClassType xml_class_;
private:
// noncopyable
Xml(const Xml&);
Xml& operator=(const Xml&);
protected:
explicit Xml(const Glib::ConstructParams& construct_params);
explicit Xml(GladeXML* castitem);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
public:
virtual ~Xml();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
static GType get_type() G_GNUC_CONST;
static GType get_base_type() G_GNUC_CONST;
#endif
///Provides access to the underlying C GObject.
GladeXML* gobj() { return reinterpret_cast<GladeXML*>(gobject_); }
///Provides access to the underlying C GObject.
const GladeXML* gobj() const { return reinterpret_cast<GladeXML*>(gobject_); }
///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
GladeXML* gobj_copy();
private:
//Ignore private glade_xml functions.
protected:
/** Loads a glade XML file.
* @throw XmlError
*/
Xml(const std::string& filename, const Glib::ustring& root, const Glib::ustring& domain);
/** Reads glade XML data from memory.
* @throw XmlError
*/
Xml(const char* buffer, int size, const Glib::ustring& root, const Glib::ustring& domain);
Gtk::Widget* get_widget_checked(const Glib::ustring& name, GType type);
GtkWidget* get_cwidget(const Glib::ustring& name);
public:
typedef Gnome::Glade::XmlError Error;
/** Loads a glade XML file.
* @throw XmlError
*/
static Glib::RefPtr<Xml> create(const std::string& filename,
const Glib::ustring& root = Glib::ustring(),
const Glib::ustring& domain = Glib::ustring());
/** Reads glade XML data from memory.
* @throw XmlError
*/
static Glib::RefPtr<Xml> create_from_buffer(const char* buffer, int size,
const Glib::ustring& root = Glib::ustring(),
const Glib::ustring& domain = Glib::ustring());
std::string get_filename() const;
//void glade_xml_signal_connect (GladeXML *self,
// const char *handlername,
// GCallback func);
//void glade_xml_signal_connect_data (GladeXML *self,
// const char *handlername,
// GCallback func,
// gpointer user_data);
//
//void glade_xml_signal_autoconnect (GladeXML *self);
//
//
//typedef void (*GladeXMLConnectFunc) (const gchar *handler_name,
// GObject *object,
// const gchar *signal_name,
// const gchar *signal_data,
// GObject *connect_object,
// gboolean after,
// gpointer user_data);
//
//
//void glade_xml_signal_connect_full (GladeXML *self,
// const gchar *handler_name,
// GladeXMLConnectFunc func,
// gpointer user_data);
//
//void glade_xml_signal_autoconnect_full (GladeXML *self,
// GladeXMLConnectFunc func,
// gpointer user_data);
//
//
/** Get a widget from the glade file.
* For instance:
* @code
* Gtk::Table* pTable = dynamic_cast<Gtk::Table*>(refXml->get_widget("mytable"));
* @endcode
* @param name The name of the widget.
* @return A pointer to the widget, or <tt>0</tt> on failure.
*/
Gtk::Widget* get_widget(const Glib::ustring& name);
/** This is for convenience.
* It allows for a shorter syntax with less repetition. For instance:
* @code
* Gtk::Table* pTable = 0;
* refXml->get_widget("mytable", pTable);
* @endcode
* This method prints a warning message to the console if the widget
* doesn't exist or has the wrong type, so you don't need to check that
* manually.
* @param name The name of the widget.
* @retval widget A pointer to the widget, or <tt>0</tt> on failure.
* @return The value of @a widget.
*/
template <class T_Widget> inline
T_Widget* get_widget(const Glib::ustring& name, T_Widget*& widget)
{
// The dynamic_cast<> should never fail if get_widget_checked() succeeded.
widget = dynamic_cast<T_Widget*>(this->get_widget_checked(name, T_Widget::get_base_type()));
if(!widget)
g_critical("Gnome::Glade::Xml::get_widget(): dynamic_cast<> failed.");
return widget;
}
/** This provides a pointer to a widget whose details are specified in the Glade file, but which is implemented
* by your own derived class. Your class must have a constructor like so:
* @code
* DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gnome::Glade::Xml>& refGlade)
* : Gtk::Dialog(cobject) //Calls the base class constructor
* @endcode
*
* For instance:
* @code
* Gtk::DerivedBox* pBox = 0;
* refXml->get_widget_derived("mybox", pBox);
* @endcode
*
* @param name The name of the widget.
* @retval widget A pointer to the widget, or <tt>0</tt> on failure.
* @return The value of @a widget.
*/
template <class T_Widget> inline
T_Widget* get_widget_derived(const Glib::ustring& name, T_Widget*& widget)
{
// initialize input parameter
widget = 0;
// Get the widget from the glade file.
typedef typename T_Widget::BaseObjectType cwidget_type;
cwidget_type* pCWidget = (cwidget_type*)get_cwidget(name);
//The error was already reported by get_cwidget().
if(!pCWidget)
return 0;
//Check whether there is already a C++ wrapper instance associated with this C instance:
Glib::ObjectBase* pObjectBase = ObjectBase::_get_current_wrapper((GObject*)pCWidget);
//If there is already a C++ instance, then return it again:
if(pObjectBase)
{
widget = dynamic_cast<T_Widget*>( Glib::wrap((GtkWidget*)pCWidget) );
//Newer, more spec-complaint, versions of g++ not resolve a specific wrap() function in a template.
//The dynamic cast checks that it is of the correct type.
//Somebody might be trying to call get_widget_derived() after already calling get_widget(),
//or after already calling get_widget_derived() with a different derived C++ type.
if(!widget)
g_critical("Gnome::Glade::Xml::get_widget_derived(): dynamic_cast<> failed. An existing C++ instance, of a different type, seems to exist.");
}
else
{
//Create a new C++ instance to wrap the existing C instance:
//Set the output variable. We needed to do this because we can not template the return type.
Glib::RefPtr<Gnome::Glade::Xml> refThis(this);
refThis->reference(); //take a copy.
widget = new T_Widget(pCWidget, refThis);
}
//We return it as well (we need the parameter as well, because C++ can not just template the return type.)
return widget;
}
Glib::ListHandle<Gtk::Widget*> get_widget_prefix(const Glib::ustring& name);
///Take the widget from the glade-generated container and put it in another container.
void reparent_widget(const Glib::ustring& name, Gtk::Container& container);
std::string relative_file(const std::string& filename) const;
static Glib::ustring get_widget_name(Gtk::Widget& widget);
static Glib::RefPtr<Xml> get_widget_tree(Gtk::Widget& widget);
/** Connect a Gtk::Button's clicked signal or a Gtk::MenuItem's activated signal to a slot.
*
* For instance:
* @code
* refXml->connect_button("button", sigc::mem_fun(*this, &ExampleWindow::on_button_clicked) );
* @endcode
*
* @param name The name of the widget.
* @param pslot The slot to connect to.
*/
void connect_clicked(const Glib::ustring& name, const sigc::slot<void>& slot_);
///* interface for changing the custom widget handling */
//typedef GtkWidget *(* GladeXMLCustomWidgetHandler) (GladeXML *xml,
// gchar *func_name,
// gchar *name,
// gchar *string1,
// gchar *string2,
// gint int1,
// gint int2,
// gpointer user_data);
//void glade_set_custom_handler(GladeXMLCustomWidgetHandler handler,
// gpointer user_data);
protected:
virtual GType lookup_type_vfunc(const Glib::ustring& classname);
public:
public:
//C++ methods used to invoke GTK+ virtual functions:
protected:
//GTK+ Virtual Functions (override these to change behaviour):
//Default Signal Handlers::
};
} // namespace Glade
} // namespace Gnome
namespace Glib
{
/** @relates Gnome::Glade::Xml
* @param object The C instance
* @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
* @result A C++ instance that wraps this C instance.
*/
Glib::RefPtr<Gnome::Glade::Xml> wrap(GladeXML* object, bool take_copy = false);
}
#endif /* _LIBGLADEMM_XML_H */

15
libs/libglademm/libglademmconfig.h
View File

@@ -1,15 +0,0 @@
/* libglade/libglademmconfig.h. Generated by configure. */
#ifndef _LIBGLADEMM_CONFIG_H
#define _LIBGLADEMM_CONFIG_H 1
#include "gtkmmconfig.h"
/* version numbers */
#define LIBGLADEMM_MAJOR_VERSION 2
#define LIBGLADEMM_MINOR_VERSION 6
#define LIBGLADEMM_MICRO_VERSION 1
#define LIBGLADEMM_VERSION "2.6.1"
#define LIBGLADE_VERSION_NEEDED_QUOTED "2.3.6"
#endif /* _LIBGLADEMM_CONFIG_H */

601
libs/sigc++2/ChangeLog
View File

@@ -1,3 +1,604 @@
2.0.17:
2005-12-20 Murray Cumming <murrayc@murrayc.com>
* sigc++/macros/signal.h.m4: Make all operator--() methods
return by reference, like the operator++() methods.
Bug #304402 from John Profic.
This is the libsigc-2-0 branch, for maintenance of libsigc++ 2.0.
API/ABI-compatible API-addition happens in the HEAD branch.
2005-12-01 Murray Cumming <murrayc@murrayc.com>
* sigc++/functors/slot_base.cc:
slot_base::disconnect(): Set call_ to 0,
to invalidate the slot, even if parent_ is 0.
I think parent_ is, for instance, a signal, but
disconnect should still work on a slot that is not
connected to a signal, because a slot can be invoked
directly.
Fixes bug #311057 from James Lin.
2005-12-01 Murray Cumming <murrayc@murrayc.com>
* tests/Makefile.am:
* tests/test_slot_disconnect.cc: Added test
case from bug #311057.
2005-11-16 Philipp Berndt <philipp.berndt@gmx.net>
* sigc++/adaptors/macros/exception_catch.h.m4: Make member
exception_catch_functor<T_functor, T_catcher, void>::catcher_
public so that it can be accessed by visit_each()
(bug fixed for generalization on 2004-11-06)
2.0.16:
2005-08-01 Neal E. Coombes <nealc@trdlnk.com>
* sigc++/signal_base.h: Updated the documentation for temp_slot_list
as requested in bug #303896.
2005-08-01 Murray Cumming <murrayc@murrayc.com>
* sigc++/adaptors/hide.h.m4: Added missing
) in call to sun_forte_workaround(), fixing
build on SUN Forte 5.5. Bug #312020.
2005-08-19 Bruno Martinez <brunom@fing.edu.uy>
* sigc++/type_traits.h: Renamed
::sigc::is_base_and_derived::internal to
::sigc::is_base_and_derived::internal_class
in order to avoid conflict with
namespace internal.
2005-07-13 Murray Cumming <murrayc@murrayc.com>
* docs/manual/libsigc_manual.xml: Correct mentions of
1.2 stuff instead of 2.0. Patch in bug #310213 from
pebble.org.uk.
2005-07-13 Murray Cumming <murrayc@murrayc.com>
* docs/manual/libsigc_manual.xml: Fixed typo
found by Antonio Coralles.
2005-07-09 Murray Cumming <murrayc@murrayc.com>
* sigc++/macros/signal.h.m4: Did the same (see
last commit) for slot_const_iterator and
slot_iterator_buf.
2005-07-09 Murray Cumming <murrayc@murrayc.com>
* sigc++/macros/signal.h.m4: slot_iterator:
operator--() now returns value, not reference, like
operator++() already did. This caused crashes when
using --no-inline with g++. Bug #308651 by
Michael Andres.
2.0.15:
2005-07-04 Philip Langdale <plangdale@vmware.com>
* sigc++/adaptors/macros/compose.h.m4: Add a setter typedef to
compose*_functor and use it instead of the (incorrect) getter
typedef in the compose* specialization of visit_each<>().
This corrects the lifetime management of slots created with
compose(). Bug #308433.
2005-06-13 Marek Rouchal <marek.rouchal@infineon.com>
* tests/test_deduce_result_type.cc: Specify int return type
for main(), to be more ISO C++ compliant. Bug #307478.
2005-06-11 Andris Pavenis <pavenis@latnet.lv>
* sigc++/adaptors/lambda/macros/base.h.m4:
* sigc++/adaptors/lambda/macros/select.h.m4
* sigc++/adaptors/macros/hide.h.m4: Specify only a type (not a
parameter name) for unused member function parameters
2005-06-12 Paul Pogonyshev <pogonyshev@gmx.net>
* configure.ac:
* scripts/cxx.m4:
* sigc++config.h.in: Add test for whether the compiler allows
referencing to member functions of the class/structure being
declared from a definition of a static member variable.
Supposedly a generic solution for GCC 3.2 compilation problems.
* sigc++/type_traits.h: Define SIGC_WRAP_IS_BASE_CLASS_ based on
results of the above test.
(struct is_base_and_derived): Wrap up is_base_class_() functions
in an internal class if SIGC_WRAP_IS_BASE_CLASS_ is defined.
2005-06-10 Murray Cumming <murrayc@murrayc.com>
* sigc++/adaptors/macros/bind.h.m4:
* sigc++/functors/macros/slot.h.m4:
* sigc++/macros/signal.h.m4: Use CALL_SIZE instead of
hard-coded 7s and 6s.
2.0.14:
2005-06-10 Murray Cumming <murrayc@murrayc.com>
* sigc++/visit_each.h: Make the
limit_derived_target::with_type inner class an outer class,
to satisfy the SUN CC 5.7 compiler, though I think it is a
compiler bug. Bug #302098 has the test case.
2.0.13:
2005-06-07 Murray Cumming <murrayc@murrayc.com>
* tests/test_compatibility.cc: Specify the actual class when
using test_int(), instead of the derived class, to fix the build
on SUN Forte CC 5.5. Patch from Friedemann Kleint in
Bug #305647
2005-06-07 Murray Cumming <murrayc@murrayc.com>
* sigc++/macros/signal.h.m4: signal_emit::emit(): Use scope to
ensure a certain order of destruction of the member variables, to
avoid a leak on MSVC++. Patch by Andreas Ames in Bug #306249.
2005-06-07 Murray Cumming <murrayc@murrayc.com>
* sigc++/macros/signal.h.m4: Added comments about commenting-out
SIGC_TYPEDEF_REDEFINE_ALLOWED when using SUN Forte CC 5.7,
because I can not seem to create a test for it.
2005-06-07 Murray Cumming <murrayc@murrayc.com>
* configure.ac:
* scripts/cxx_std.m4:
* sigc++/macros/signal.h.m4:
* sigc++config.h.in: Added check for
the non-standard SUN Forte reverse_iterator<>,
and used it. This is based on the same stuff in
gtkmm.
2005-06-07 Murray Cumming <murrayc@murrayc.com>
* sigc++/visit_each.h: limit_derived_target(): Just some whitespace
changes.
2005-05-16 Neal E. Coombes <nealc@trdlnk.com>
* sigc++/signal_base.h: Modified temp_slot_list to be a temporary view
into a slot list. Instead of emptying the original it now simply tacks
a placeholder to the end of the original. It then uses this as it's
'end' iterator. This should allow for conscious recursiveness, as well
as inserting a slot to any position in the slot list during emittion.
See bug #303896.
2005-06-04 Friedemann Kleint <kleint@bifab.de>
* sigc++/macros/limit_reference.h.m4:
visit_each() template specializations:
Mention the bool I_derives_trackable
template type, to fix the build on Solaris
Forte 5.5.
2.0.12:
2005-05-06 Régis Duchesne <hpreg@vmware.com>
* sigc++/macros/limit_reference.h.m4 (added):
* sigc++/Makefile.am:
New class that just stores a reference, and makes sure that if the
reference derives from trackable, then the trackable reference will be
used instead of the derived reference in visit_each().
* sigc++/functors/macros/mem_fun.h.m4: Better fix for bug #169225 by
Régis Duchesne and Christian Hammond, based on the new limit_reference
class.
* sigc++/adaptors/bound_argument.h (added): New class (built upon the
new limit_reference class) that handles all 3 kinds of bound arguments:
by value, by reference, and by constant reference. References are
unwrapped in the bound_argument's constructor.
* sigc++/adaptors/macros/bind.h.m4: Fix for bug #302327 by Régis
Duchesne. Bound arguments now need to know whether they are passed by
reference or not. So bind() now builds bind_functor instances using
'reference_wrapper<Foo>' types, instead of 'Foo &' types. The
bind_functor code is modified to compensate.
* sigc++/adaptors/macros/bind_return.h.m4: Similar fix for a similar
bug (unfiled) with bound return arguments.
* sigc++/reference_wrapper.h:
* sigc++/type_traits.h:
The reference_wrapper class is only used in bound_argument.h. Put
correct but unused code under #if 0.
* sigc++/adaptors/lambda/base.h: This file needs reference_wrapper.h,
but was incorrectly relying on type_traits.h to include it.
* tests/Makefile.am:
* tests/test_virtualbase_delete.cc (deleted):
* tests/test_virtualbase_delete_ref_param.cc (deleted):
* tests/test_limit_reference.cc (added):
Replaced test_virtualbase_delete*.cc with a simpler
test_limit_reference.cc which checks for all 3 aspects of the same bug
in one file.
* tests/test_bind_ref.cc: Slots must use 'Foo &' types. We were lucky
this broken usage worked before this change. The change in
type_traits.h made this bug obvious, by preventing the code to compile.
* tests/test_bind_return.cc: After my change, bind() and bind_return()
must use 'reference_wrapper<Foo>' types.
* tests/test_custom.cc: Made this test a no-op (so it does not perturb
'make check' on released versions of the library) and made it a
template ready to be modified by hackers.
2005-05-01 Murray Cumming <murrayc@murrayc.com>
* sigc++/functors/slot_base.cc:
slot_base::slot_base(src): If the source
slot_base has a null rep->call_, meaning that the
slot is invalid, just return a default-constructed
slot, to prevent the crash shown in
tests/tests_copy_invalid_slot.cc. Bug #302515 by
Régis Duchesne.
2005-05-01 Murray Cumming <murrayc@murrayc.com>
* sigc++/functors/macros/mem_fun.h.m4: bound_*<>:
Add a new is_base_and_derived<sigc::trackable>
parameter to the template and thereby provide a
specialization for T_Obj types that derive from
sigc::trackable. This prevents a crash when casting
from the derived type to sigc::trackable after the
derived destructor has run. This cast can sometimes
fail when using multiple inheritance, at least with
g++. Bug #169225 by Régis Duchesne and Christian
Hammond.
* sigc++/type_traits.h: Add documenation for
the internal is_base_and_derived<> template, which
allows us to specialize other templates for certain
template types.
2005-04-28 Murray Cumming <murrayc@murrayc.com>
* sigc++/type_traits.h: Added comments for users of
g++ 3.2.
2005-04-28 Murray Cumming <murrayc@murrayc.com>
* tests/Makefile.am:
* tests/test_virtualbase_delete.cc: Added
simplified test case from bug #169225. We have a patch
to make this succeed but I am not ready to commit it
just yet.
2005-04-27 Murray Cumming <murrayc@murrayc.com>
* tests/Makefile.am:
* tests/test_custom.cc:
Added a place to put extra test code, so I don't have
to keep installing my crazy libsigc++ versions.
2005-04-27 Murray Cumming <murrayc@murrayc.com>
* sigc++/visit_each.h: Revert back to the non-explicit
template call, because we can not specify the
template specialization so easily, because the
specializations have different numbers of types.
* tests/Makefile/am:
* tests/test_bind_ref.cc: Add a simple test only for
sigc::ref disconnection.
2005-04-26 Murray Cumming <murrayc@murrayc.com>
* sigc++/visit_each.h: Use the explicit template
specialization, needed for Tru64 and AIX compilers.
This causes a crash in some uses of sigc::ref()
(when using g++ 3.3.4 or 3.3.5 , but not with 3.4) but
seems to fix a crash in some uses of multiple inheritance
(bug #169225).
* tests/test_bind.cc: Comment out the crashing (not with
g++ 3.4) use of sigc::ref() with an explanatory comment.
2.0.11:
2005-03-09 Cedric Gustin <cedric.gustin@swing.be>
* Makefile.am: Moved MSVC_Net2003 directory to SUBDIRS.
* MSVC_Net2003/Makefile.am: Added blank.cpp to EXTRA_DIST.
* MSVC_Net2003/libsigc++2_msvcNet2003.sln: Removed
test_accumulated and test_lambda projects as the tests are
disabled in the standard, configure-based build.
* MSVC_Net2003/MSVC_Net2003/libsigc++2_msvcNet2003.vcproj:
Generate a PDB file in the Debug target.
2005-03-05 Murray Cumming <murrayc@murrayc.com>
* docs/website/stable.html: Mention actual supported compilers.
* docs/website/docs.html: Removed broken examples links. Change
reference link to the reference overview page.
2005-02-23 Murray Cumming <murrayc@murrayc.com>
* sigc++/functors/slot_base.h: Make slot_base::operator=() public, to
fix the build with SUN Forte C++ 5.5 and Tru64.
2.0.10:
2005-02-20 Murray Cumming <murrayc@murrayc.com>
* tests/test_slot.cc, test_disconnect.cc: #included <new> to avoid
an unresolved symbol error with the Tru64 compiler. Solution found by
Tim Mooney in bug #161503.
2005-02-20 Martin Schulze <mschulze@cvs.gnome.org>
* sigc++/signal_base.h: Add some documentation.
2005-02-20 Martin Schulze <mschulze@cvs.gnome.org>
* sigc++/signal_base.cc: Reset deferred_ flag to false in
signal_impl::sweep() (Neal E. Coombes). Partly fixes bug #167714.
2005-02-11 Martin Schulze <mschulze@cvs.gnome.org>
* docs/manual/Makefile.am: Set the correct group in post-html.
2005-02-11 Murray Cumming <murrayc@murrayc.com>
* docs/website/doc.shtml: Fix typo in url for reference docs. Found by
James Lin.
2005-02-06 Murray Cumming <murrayc@murrayc.com>
* sigc++/signal_base.h: temp_slot_list::begin(), end(): Actually
return the iterators.
2005-02-03 Neal E. Coombes <nealc@trdlnk.com>
* sigc++/signal_base.h: Add temp_slot_list struct to facilitate
allowing new connections to a signal during an emittion without
affecting that emittion.
* sigc++/macros/signal.h.m4: Use the new struct temp_slot_list to
prevent connections made during an emittion from being called in the
same emittion (which has the potential of causing things like
infinite loops). This guarantees an emittion will be finite, as well
as maintaining any order of emittion guarantees that may have already
been in place.
2.0.9:
2005-02-02 Murray Cumming <murrayc@murrayc.com>
* sigc++/visit_each.h: visit_each_type(): Reverted the change, so that
we do not specify the template types ot visit_each<>(), because it
crashes on g++ 3.3.4 (but not g++ 3.4.2). Added a comment telling users
of AIX (and maybe IRIX MipsPro and Tru64) to use the alternative version
if they have compilation problems.
2005-02-01 Murray Cumming <murrayc@murrayc.com>
* sigc++/adapators/macros/base.h.m4: Add sigc::var<>() documentation,
from Roger Ferrer Ibáñez in bug #149483.
2005-02-01 Murray Cumming <murrayc@murrayc.com>
* sigc++/adaptors/macros/compose.h.m4: In the template specializations
of visit_each(): As before, specify the specific other template
specializations of visit_each that we use. Needed by AIX.
* tests/Makefile.am: Reenabled most tests, because AIX can now
build them.
2005-02-01 Murray Cumming <murrayc@murrayc.com>
* sigc++/visit_each.h: visit_each_type(): Specify the specific
template specialization of visit_each<>() to use. The AIX compiler,
and possibly the Tru64 compiler, need this extra hint.
2005-02-01 Murray Cumming <murrayc@murrayc.com>
* bind.h.m4: Define bind_functor::operator() inline because the AIX
compiler/linker sometimes fails to find it when it is defined
outside of the class.
2.0.8:
2005-01-30 Murray Cumming <murrayc@murrayc.com>
* sigc++/type_traits.h: is_base_and_derived: Added
avoid_gcc3_warning_(), to avoid an incorrect warning when using
g++ 3.3.5
2005-01-28 Liza Klerck <liza@trdlnk.com>
* sigc++/functors/macros/mem_fun.h.m4: Add a sigc:: namespace
prefix to the nested use of visit_each(), to avoid ambiguity when
using 2 versions of the libsigc++ API inside different namespace.
2005-01-27 Murray Cumming <murrayc@murrayc.com>
* sigc++/adaptors/macros/adaptor_trait.h.m4: Add a sigc:: namespace
prefix to the nested use of visit_each(), to avoid ambiguity when
using 2 versions of the libsigc++ API inside different namespace,
which is not very advisable anyway. Bug #165222 from
liza at trdlnk.com.
2.0.7:
2005-01-24 Cedric Gustin <cedric.gustin@swing.be>
* sigc++config.h.in : Moved the SIGC_USING_STD macro definition
out of the SIGC_CONFIGURE section. We also need it for MSVC.
* MSVC_Net2003/.cvsignore : Added .def and .aps files
* MSVC_Net2003/Makefile.am: Rewrote rule for local copy of
sigc++config.h (required for 'make distcheck').
* MSVC_Net2003/libsigc++2_msvcNet2003.sln: Added test_retype and
test_disconnect_during_emit tests.
* MSVC_Net2003/tests/test_disconnect_during_emit/*,
MSVC_Net2003/tests/test_retype/*: Initial commit.
2005-01-21 Murray Cumming <murrayc@murrayc.com>
* tests/: Disabled the test_accumulator, test_bind, and test_compose
tests, and part of test_mem_fun because the AIX xlC compiler can not
build them, but it can still do most things, including the examples.
See the comments in tests/Makefile.am.
2005-01-21 Murray Cumming <murrayc@murrayc.com>
* sigc++/adaptors/bind.h.m4: non-member operator()(): Specify the
extra nil arguments in the templated class name prefix. Oddly, the
AIX xlC compiler says that the type of the first parameter does not
match the template if you don't do this.
2005-01-21 Murray Cumming <murrayc@murrayc.com>
* sigc++/type_traits.h: is_base_and_derived struct: Move the
is_base_class_() functions out of the inner class, because the AIX
xlC compiler does not like that - see the comments in the code.
* sigc++/adaptors/bind.h.m4: Add the extra nil template types to
the template specializations, as in slot and signal.
2005-01-21 Murray Cumming <murrayc@murrayc.com>
* sigc++/functors/macros/slot.h.m4, sigc++/macros/signal.h.m4:
slot and signal template specialization for
various numbers of template args: In the class slot line, specify
all the remaining template types as null, instead of expecting the
compiler to guess them in itself. This partly fixes the build on
AIX with the xlC compiler. Bug #164685.
2005-01-19 Murray Cumming <murrayc@murrayc.com>
* sigc++/type_traits: struct is_base_and_derived: Make the test inner
struct a friend, so that it can use the big inner struct. This is
required by the Tru64 compiler.
* sigc++/adaptors/lambda/base.h: Put the unwrap_lambda_value()
definitions at the top, because Tru64 (understandably) needs them to
be declared before use.
2005-01-19 Murray Cumming <murrayc@murrayc.com>
* scripts/: Added cxx_std.m4, with a test copied from
glibmm/scripts/cxx_std.m4 to check if the compiler has the std::
namespace.
* sigcconfig.h: #undef the new #define and add SIGC_USING_STD(),
like GLIBMM_USING_STD, to put stuff in the std:: namespace when it
is not there already,
* configure.in: Used the new test.
* tests/*: Uses SIG_USING_STD() for every std:: thing that we use.
This is needed by the Tru64 and HP-UX compilers when using their
defaults.
2005-01-19 Murray Cumming <murrayc@murrayc.com>
* configure.in: AC_INIT(): Provide the extra tarball name parameter,
so that it does not create a libsigc--- tarball.
2005-01-19 Murray Cumming <murrayc@murrayc.com>
* configure.in: AC_INIT(): Use libsigc++ instead of sigc++, attempting
to get the correct tarball name.
2005-01-18 Murray Cumming <murrayc@murrayc.com>
* configure.in: Used the autoconf 2.93 and AM_INIT_AUTOMAKE()
technique to specify ustar format for the tarball, to prevent files
with long file names from appearing at the top of the tarball.
Based on the same fix in gtkmm 2.6.
2005-01-18 Murray Cumming <murrayc@murrayc.com>
* sigc++/functors/macros/slot_h.m4: Specify the base class when
using the rep_ member variable. This stops the HP-UX aCC compiler
from saying that a Nonstatic member is referenced in a nested class,
local class or static member initializer. Bug #150719.
2005-01-18 Murray Cumming <murrayc@murrayc.com>
* Bug #159597 - patch from e97_far at e.kth.se to replace C-style
casts with reinterpret_cast<> and static_cast<> to avoid warnings.
2005-01-17 Murray Cumming <murrayc@murrayc.com>
* docs/manual/Makefile.am: Specifying html/index.html instead of
just the html directory as a target seems to fix distcheck problems.
I can also now confirm that the install works on solaris, when using
gmake, though not when using make.
2005-01-17 Murray Cumming <murrayc@murrayc.com>
* MSVC_Net2004/Makefile.am: Add built files to DISTCLEANFILES to fix
the distcheck.
* docs/reference/Makefile.am, manual/Makefile.am: Specify $srcdir in
paths, to fix distcheck of the manual, and maybe fix install problems
on Solaris.
2005-01-11 Murray Cumming <murrayc@murrayc.com>
* docs/website/stable.html: Updated the text about binary packages.
* docs/website/docs.html: Link to the 2.0 documentation instead of the
1.2 documentation.
2004-12-17 GregSchussman <schussman@slac.stanford.edu>
* glossary.shtml: Clean up punctuation, make definitions complete
sentences, and add clarifications for certain definitions according to
what Murray Cumming's suggestions and answers to my questions.
Bug #161580.
2005-01-11 Murray Cumming <murrayc@murrayc.com>
* docs/: Added manual, copied from the libsigc++-1.2 cvs module,
and updated it for the new 2.0 API.
2005-01-11 Murray Cumming <murrayc@murrayc.com>
* docs/: Added website, copied from the libsigc++-1.2 cvs module.
We will use it from here from now on.
2004-12-11 Cedric Gustin <cedric.gustin@swing.be>
* configure.ac : parse version tags at configure time (for
sigc-2.0.rc).
* MSVC_Net2003/sigc-2.0.rc.in : New resource file.
* MSVC_Net2003/Makefile.am: include sigc-2.0.rc in distribution.
2004-12-08 Cedric Gustin <cedric.gustin@swing.be>
* MSVC_Net2003/Makefile.am: get sigc++config.h from $(top_builddir)
instead of $(top_srcdir).
2004-12-08 Cedric Gustin <cedric.gustin@swing.be>
* MSVC_Net2003/*/*.vcproj: Renamed libsigc++ target to
sigc-2.0d.dll (Debug) and sigc-2.0.dll (Release). Added
$(SolutionDir) and $(SolutionDir)\.. to "Additional Include
Directories" in tests projects.
* sigc++config.h.in: Rewrote dllexport/dllimport macros for
MSVC, for better consistency with glibmm/gtkmm.
* MSVC_Net2003/Makefile.am: copy sigc++config.h from $(top_srcdir)
at build time.
2004-11-27 Murray Cumming <murrayc@murrayc.com>
* configure.in: Revert the AC_PROG_LIBTOOL change, so that this builds
with actually released libtool versions, and in jhbuild, so that it
gets testing.
2004-11-06 Martin Schulze <mschulze@cvs.gnome.org>
* sigc++/adaptors/macros/exception_catch.h.m4: Make catcher_ member
public so that it can be accessed by visit_each() (bug reported on
ml by Philip Langdale <plangdale@vmware.com>).
2004-10-24 Martin Schulze <mschulze@cvs.gnome.org>
* MSVC_Net2003/*/*.vcproj: Link with the "multithreaded DLL" runtime
libraries and enable RTTI for the MSVC build
(patch from Timothy M. Shead <tshead@k-3d.com>).
* MSVC_Net2003/*/.cvsignore: Hide generated build files from cvs
(patch from Timothy M. Shead <tshead@k-3d.com>).
2.0.6:
2004-10-12 Martin Schulze <mschulze@cvs.gnome.org>
* MSVC_Net2003/*/*.vcproj, MSVC_Net2003/blank.cpp: Fix project files

3
libs/sigc++2/Makefile.am
View File

@@ -5,7 +5,7 @@ EXTRA_DIST = autogen.sh sigc++config.h.in libsigc++-2.0.spec.in
# ACLOCAL_FLAGS = -I scripts
SUBDIRS = sigc++
DIST_SUBDIRS = $(SUBDIRS)
DIST_SUBDIRS = $(SUBDIRS)
sigc_configdir = $(libdir)/sigc++-2.0/include
sigc_config_DATA = sigc++config.h
@@ -28,3 +28,4 @@ dist-hook:
echo "**********************************************************"; \
echo; echo \
cp libsigc++-2.0.spec $(distdir)

110
libs/sigc++2/NEWS
View File

@@ -1,21 +1,107 @@
*** libsigc++ 2.0:
2.0.17:
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.
* slot::disconnect(): Make this work.
sigc::connection::disconnect() already worked.
(James Lin, Murray Cumming)
* visit_each compilation problem fixed.
(Philipp Berndt)
libsigc++ is used by gtkmm to wrap the GTK+ signal system. It does not depend
on GTK or gtkmm.
2.0.16:
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.
* Fixed build for SUN Forte C++ 5.5
* Fixed build for MSVC++ 7.1
* Fixed crash when using --no-inline with g++.
This version of libsigc++ needs GNU g++ 3.2 or higher to compile.
2.0.15:
* g++ 3.2 (and Mac OS X g++ 3.3) build fix.
(Paul Pogonyshev)
* Compose: Fix slot lifetime regression introduced in
2.0.9. (Philip Langdale)
* tests: Small ISO C++ correctness fix (Marek Rouchal)
* Don't specify unused function parameter names.
(Andris Pavenis)
2.0.14:
* SUN Forte 5.7 build fix for ambiguity when using
inner template class. However, you still need the
patch in bug #302098 to finish the build.
2.0.13:
* signal_emit::emit(): Ensure the correct order of
destruction of the member variables, to avoid a leak.
(Andreas Ames, bug #306249)
* Allow recursive signal emission again.
(Neal E. Coombes, bug #303896)
* SUN Forte CC 5.5 build fixes:
- test_compatibility minor fix.
- visit_each() template specializations:
Mention the bool I_derives_trackable template type,
(Friedemann Kleint, bug #305647)
- Check for the non-standard SUN reverse_iterator,
and use alternative code if necessary.
(Murray Cumming)
2.0.12:
* Fixes crashes when using virtual inheritance, particularly
with bound by-reference parameters, caused by casting
from derived to base when the derived destructor has run.
(Régis Duchesne)
This might affect non-g++ compilers, so do tell us about
any problems.
2.0.11:
* Build fixes for SUN Forte, Tru64
(Murray Cumming), and MSVC++ (Cedric Gustin).
2.0.10:
* tests: Include <new> to avoid unresolved symbols on Tru64.
(Tim Mooney)
* When signal handlers are connected made during an emit
of the same signal, prevent them from being called in the
same emit, to prevent infinite loops.
(Neal E. Coombes)
* Performance improvement in a corner case.
(Neal E. Coombes).
2.0.9:
* sigc::bind() now works with the AIX and Tru64 compilers.
See the comments in sigc++/visit_each.h: visit_each_type()
if you have compilation problems.
(Murray Cumming)
* sigc::var() is now documented. (Roger Ferrer Ibáñez)
2.0.8:
* Maybe avoid (incorrect) warning with g++ 3.3.5.
(Murray Cumming)
* Fix namespace ambiguity when using multiple
major versions of libsigc++. (Liza Klerck)
2.0.7:
* Now builds with the following compilers, in addition to
the existing GNU g++, SUN Forte CC 5.5, MSVC++ .Net 2003,
and Intel compilers:
- IBM AIX xlC v7
- Tru64 C++ V6.5-042
- IRIX MIPSpro 7.4.2m
(Older versions of all these compilers might also work.)
(Murray Cumming, www.thewrittenword.com)
* MSVC++ .Net 2003 build improvements.
(Cedric Gustin, Timothy M. Shead)
* Replace C-style casts with reinterpret_cast<> and
static_cast<>. (e97_far at e.kth.se).
* Documentation: Added manual, based on the manual in
libsigc++ 1.2, but updated for the new API.
(Murray Cumming)
*** ChangeLog summary:
2.0.6:

9
libs/sigc++2/autogen.sh
View File

@@ -3,12 +3,17 @@
srcdir=`dirname $0`
test -z "$srcdir" && srcdir=.
#echo "Adding libtools."
#libtoolize --automake --copy --force
PKG_NAME="sigc++"
echo "Adding libtools."
libtoolize --automake --copy --force
echo "Building macros."
aclocal -I "$srcdir/scripts" $ACLOCAL_FLAGS
#echo "Building config header."
#autoheader
echo "Building makefiles."
automake --add-missing --copy

82
libs/sigc++2/configure.ac
View File

@@ -3,27 +3,64 @@ 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++)
#We use pushdef here because we can't use shell variables before AC_INIT, but we want to use a variable with AC_INIT:
dnl thus make format_package-0.0.1.tar.gz
pushdef([FP_MAJOR_VERSION], [2])
pushdef([FP_MINOR_VERSION], [0])
pushdef([FP_MICRO_VERSION], [17])
pushdef([FP_EXTRA_VERSION], [])
pushdef([FP_VERSION], FP_MAJOR_VERSION.FP_MINOR_VERSION.FP_MICRO_VERSION[]FP_EXTRA_VERSION)
# package name, version, support contact, tarball name.
AC_INIT([libsigc++], FP_VERSION, [libsigc-list@gnome.org], [libsigc++])
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 AC_CONFIG_SRCDIR 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_CONFIG_SRCDIR([sigc++])
AC_PREREQ(2.59)
#########################################################################
# Version and initialization
#########################################################################
[FP_MAJOR_VERSION]=FP_MAJOR_VERSION
[FP_MINOR_VERSION]=FP_MINOR_VERSION
[FP_MICRO_VERSION]=FP_MICRO_VERSION
[FP_EXTRA_VERSION]=FP_EXTRA_VERSION
[FP_VERSION]=FP_VERSION
popdef([FP_MAJOR_VERSION])
popdef([FP_MINOR_VERSION])
popdef([FP_MICRO_VERSION])
popdef([FP_EXTRA_VERSION])
popdef([FP_VERSION])
FP_RELEASE=$FP_MAJOR_VERSION.$FP_MINOR_VERSION
AC_DEFINE_UNQUOTED(FP_MAJOR_VERSION, $FP_MAJOR_VERSION, [Major version of libsigc++])
AC_DEFINE_UNQUOTED(FP_MINOR_VERSION, $FP_MINOR_VERSION, [Minor version of libsigc++])
AC_DEFINE_UNQUOTED(FP_MICRO_VERSION, $FP_MICRO_VERSION, [Micro version of libsigc++])
AC_SUBST(FP_VERSION)
AC_SUBST(FP_RELEASE)
AC_SUBST(FP_MAJOR_VERSION)
AC_SUBST(FP_MINOR_VERSION)
AC_SUBST(FP_MICRO_VERSION)
dnl For automake.
VERSION=$FP_VERSION
PACKAGE=libsigc++
dnl Initialize automake stuff
AM_INIT_AUTOMAKE($PACKAGE, $VERSION)
# Initialize automake stuff
# tar-ustar asks it to use a sensible tar format that can handle long filenames.
AM_INIT_AUTOMAKE([1.9 tar-ustar])
dnl Specify a configuration file:
AC_CONFIG_HEADER(sigc++config.h)
dnl Macros to support windows platforms
AC_CYGWIN
#AC_MINGW32
AC_EXEEXT
dnl this package needs m4
AC_CHECK_PROGS(M4, gm4 m4, m4)
dnl disable autoheader
AUTOHEADER=':'
@@ -34,16 +71,34 @@ dnl Using C compiler
AC_PROG_CC
AC_PROG_CPP
dnl Used for enabling the "-no-undefined" flag while generating DLLs
dnl Borrowed from the official gtk+-2 configure.in
AC_MSG_CHECKING([for some Win32 platform])
case "$host" in
*-*-mingw*|*-*-cygwin*)
platform_win32=yes
;;
*)
platform_win32=no
;;
esac
AC_MSG_RESULT([$platform_win32])
AM_CONDITIONAL(PLATFORM_WIN32, test "$platform_win32" = "yes")
dnl Using libtool
AC_CONFIG_MACRO_DIR(scripts)
dnl LT_INIT
dnl AM_PROG_LIBTOOL
AC_LIBTOOL_WIN32_DLL
dnl: Use with libtool 1.5a instead of AM_PROG_LIBTOOL: LT_INIT
AM_PROG_LIBTOOL
dnl Using C++ compiler
AC_PROG_CXX
AC_LANG_CPLUSPLUS
SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD()
SIGC_CXX_SELF_REFERENCE_IN_MEMBER_INITIALIZATION()
SIGC_CXX_HAS_NAMESPACE_STD()
SIGC_CXX_HAS_SUN_REVERSE_ITERATOR()
if test "X$config_error" = "Xyes" ; then
AC_ERROR(
@@ -61,4 +116,5 @@ AC_OUTPUT([
sigc++/Makefile
libsigc++-2.0.spec
])

28
libs/sigc++2/scripts/cxx.m4
View File

@@ -47,6 +47,7 @@ AC_TRY_COMPILE(
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(
@@ -92,3 +93,30 @@ AC_TRY_COMPILE(
AC_MSG_RESULT([$sigcm_cxx_msvc_template_specialization_operator_overload])
])
])
AC_DEFUN([SIGC_CXX_SELF_REFERENCE_IN_MEMBER_INITIALIZATION], [
AC_MSG_CHECKING([if C++ compiler allows usage of member function in initialization of static member field.])
AC_TRY_COMPILE(
[
struct test
{
static char test_function();
// Doesn't work with e.g. GCC 3.2. However, if test_function()
// is wrapped in a nested structure, it works just fine.
static const bool test_value
= (sizeof(test_function()) == sizeof(char));
};
],
[],
[
sigcm_cxx_self_reference_in_member_initialization=yes
AC_DEFINE([SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION],[1],
[does c++ compiler allows usage of member function in initialization of static member field.])
AC_MSG_RESULT([$sigcm_cxx_self_reference_in_member_initialization])
],[
sigcm_cxx_self_reference_in_member_initialization=no
AC_MSG_RESULT([$sigcm_cxx_self_reference_in_member_initialization])
])
])

77
libs/sigc++2/scripts/cxx_std.m4 Normal file
View File

@@ -0,0 +1,77 @@
cv_cxx_has_namespace_std
## SIGC_CXX_HAS_NAMESPACE_STD()
##
## Test whether libstdc++ declares namespace std. For safety,
## also check whether several randomly selected STL symbols
## are available in namespace std.
##
## On success, #define SIGC_HAVE_NAMESPACE_STD to 1.
##
AC_DEFUN([SIGC_CXX_HAS_NAMESPACE_STD],
[
AC_CACHE_CHECK(
[whether C++ library symbols are declared in namespace std],
[sigc_cv_cxx_has_namespace_std],
[
AC_TRY_COMPILE(
[
#include <algorithm>
#include <iterator>
#include <iostream>
#include <string>
],[
using std::min;
using std::find;
using std::copy;
using std::bidirectional_iterator_tag;
using std::string;
using std::istream;
using std::cout;
],
[sigc_cv_cxx_has_namespace_std="yes"],
[sigc_cv_cxx_has_namespace_std="no"]
)
])
if test "x${sigc_cv_cxx_has_namespace_std}" = "xyes"; then
{
AC_DEFINE([SIGC_HAVE_NAMESPACE_STD],[1], [Defined when the libstdc++ declares the std-namespace])
}
fi
])
## SIGC_CXX_HAS_SUN_REVERSE_ITERATOR()
##
## Check for Sun libCstd style std::reverse_iterator, which demands more than just one template parameter.
## and #define SIGC_HAVE_SUN_REVERSE_ITERATOR if found.
##
AC_DEFUN([SIGC_CXX_HAS_SUN_REVERSE_ITERATOR],
[
AC_REQUIRE([SIGC_CXX_HAS_NAMESPACE_STD])
AC_CACHE_CHECK(
[for non-standard Sun libCstd reverse_iterator],
[sigc_cv_cxx_has_sun_reverse_iterator],
[
AC_TRY_COMPILE(
[
#include <iterator>
#ifdef SIGC_HAVE_NAMESPACE_STD
using namespace std;
#endif
],[
typedef reverse_iterator<char*,random_access_iterator_tag,char,char&,char*,int> ReverseIter;
],
[sigc_cv_cxx_has_sun_reverse_iterator="yes"],
[sigc_cv_cxx_has_sun_reverse_iterator="no"]
)
])
if test "x${sigc_cv_cxx_has_sun_reverse_iterator}" = "xyes"; then
{
AC_DEFINE([SIGC_HAVE_SUN_REVERSE_ITERATOR],[1])
}
fi
])

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)
])

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

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

20
libs/sigc++2/sigc++/Makefile.am
View File

@@ -1,9 +1,10 @@
# 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
object_slot.h.m4 class_slot.h.m4 hide.h.m4 retype.h.m4 \
limit_reference.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
object_slot.h class_slot.h hide.h retype.h limit_reference.h
signal.cc : signal.h signal_base.h functors/slot.h functors/slot_base.h functors/mem_fun.h functors/functor_trait.h
@@ -57,15 +58,22 @@ nobase_library_include_HEADERS = $(sigc_m4) $(sigc_built_h) \
functors/functors.h \
functors/slot_base.h \
adaptors/adaptors.h \
adaptors/bound_argument.h \
adaptors/lambda/lambda.h
# Support for DLL on cygwin/mingw using libtool > 1.4
if PLATFORM_WIN32
win32_dlls_ldflags = -no-undefined -Wl,--export-all-symbols
else
win32_dlls_ldflags =
endif
# build the library
#lib_LTLIBRARIES = libsigc-2.0.la
#libsigc_2_0_la_SOURCES = signal.cc signal_base.cc trackable.cc connection.cc \
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 =
libsigc_2_0_la_LDFLAGS = $(win32_dlls_ldflags)
BUILT_SOURCES = $(sigc_built_h) $(sigc_built_cc)
CLEANFILES = build-subdirs-stamp

5
libs/sigc++2/sigc++/adaptors/adaptor_trait.h
View File

@@ -251,6 +251,7 @@ adaptor_functor<T_functor>::operator()() const
{ return functor_(); }
//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::adaptor_functor performs a functor
* on the functor stored in the sigc::adaptor_functor object.
@@ -261,7 +262,9 @@ 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_);
//The extra sigc:: prefix avoids ambiguity in some strange
//situations.
sigc::visit_each(_A_action, _A_target.functor_);
}

811
libs/sigc++2/sigc++/adaptors/bind.h
View File

File diff suppressed because it is too large Load Diff

74
libs/sigc++2/sigc++/adaptors/bind_return.h
View File

@@ -3,6 +3,7 @@
#ifndef _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
#define _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
#include <sigc++/adaptors/adaptor_trait.h>
#include <sigc++/adaptors/bound_argument.h>
namespace sigc {
@@ -20,29 +21,29 @@ 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;
{ typedef typename unwrap_reference<T_return>::type type; };
typedef typename unwrap_reference<T_return>::type result_type;
/** Invokes the wrapped functor dropping its return value.
* @return The fixed return value.
*/
T_return operator()();
typename unwrap_reference<T_return>::type 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)
inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); return ret_value_;
(_A_a1); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
inline T_return sun_forte_workaround(T_arg1 _A_a1)
inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); return ret_value_;
(_A_a1); return ret_value_.invoke();
}
#endif
@@ -51,16 +52,16 @@ struct bind_return_functor : public adapts<T_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)
inline typename unwrap_reference<T_return>::type 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_;
(_A_a1,_A_a2); return ret_value_.invoke();
}
#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)
inline typename unwrap_reference<T_return>::type 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_;
(_A_a1,_A_a2); return ret_value_.invoke();
}
#endif
@@ -69,16 +70,16 @@ struct bind_return_functor : public adapts<T_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)
inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
}
#endif
@@ -87,16 +88,16 @@ struct bind_return_functor : public adapts<T_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)
inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
}
#endif
@@ -105,16 +106,16 @@ struct bind_return_functor : public adapts<T_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)
inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline 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)
inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
}
#endif
@@ -123,16 +124,16 @@ struct bind_return_functor : public adapts<T_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)
inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline 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)
inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
}
#endif
@@ -141,16 +142,16 @@ struct bind_return_functor : public adapts<T_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)
inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
inline 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)
inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_;
(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
}
#endif
@@ -164,14 +165,15 @@ struct bind_return_functor : public adapts<T_functor>
{}
/// The fixed return value.
T_return ret_value_; // public, so that visit_each() can access it
bound_argument<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_; }
typename unwrap_reference<T_return>::type bind_return_functor<T_return, T_functor>::operator()()
{ this->functor_(); return ret_value_.invoke(); }
//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_return_functor performs a functor on the
* functor and on the object instance stored in the sigc::bind_return_functor object.
@@ -196,9 +198,9 @@ void visit_each(const T_action& _A_action,
* @ingroup bind
*/
template <class T_return, class T_functor>
inline bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>
inline bind_return_functor<T_return, T_functor>
bind_return(const T_functor& _A_functor, T_return _A_ret_value)
{ return bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>(_A_functor, _A_ret_value); }
{ return bind_return_functor<T_return, T_functor>(_A_functor, _A_ret_value); }
} /* namespace sigc */
#endif /* _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_ */

165
libs/sigc++2/sigc++/adaptors/bound_argument.h Normal file
View File

@@ -0,0 +1,165 @@
/*
* Copyright 2005, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _SIGC_BOUND_ARGUMENT_H_
#define _SIGC_BOUND_ARGUMENT_H_
#include <sigc++/limit_reference.h>
#include <sigc++/reference_wrapper.h>
namespace sigc {
/** A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return()) argument.
*
* If Foo is a wrapped reference to a class Bar (reference_wrapper<Bar>) then this
* object is implemented on top of a limit_reference. When the slot is
* invoked, the limit_reference::invoke() method provides the argument (a Bar&).
* When the slot is visited (e.g. visit_each<>()), we simply visit the limit_reference,
* which will visit the derived type, or a sigc::trackable base if necessary.
*
* Likewise, If Foo is a wrapped const reference to a class Bar (const_reference_wrapper<Bar>)
* then this object is implemented on top of a const_limit_reference.
*
* If Foo is something else (such as an argument that is bound by value) bound_argument just
* stores a cop of that value, and both invoke() and visit() simply return it.
*
* This object is used by the bind_functor<> and bind_return_functor<> objects,
* depending on whether the argument is bound as a parameter or as a return value.
*
* The general template implementation is used for parameters that are passed by value.
* @e T_type The type of the bound argument.
*/
template <class T_type>
class bound_argument
{
public:
/** Constructor.
* @param _A_argument The argument to bind.
*/
bound_argument(const T_type& _A_argument)
: visited_(_A_argument)
{}
/** Retrieve the entity to visit in visit_each().
* @return The bound argument.
*/
inline const T_type& visit() const
{ return visited_; }
/** Retrieve the entity to pass to the bound functor or return.
* @return The bound argument.
*/
inline T_type& invoke()
{ return visited_; }
private:
/** The value of the argument.
*/
T_type visited_;
};
//Template specialization:
/** bound_argument object for a bound argument that is passed by bind() or
* returned by bind_return() by reference, specialized for reference_wrapper<> types.
* @e T_wrapped The type of the bound argument.
*/
template <class T_wrapped>
class bound_argument< reference_wrapper<T_wrapped> >
{
public:
/** Constructor.
* @param _A_argument The argument to bind.
*/
bound_argument(const reference_wrapper<T_wrapped>& _A_argument)
: visited_(unwrap(_A_argument))
{}
/** Retrieve the entity to visit in visit_each().
* @return The limited_reference to the bound argument.
*/
inline const limit_reference<T_wrapped>& visit() const
{ return visited_; }
/** Retrieve the entity to pass to the bound functor or return.
* @return The bound argument.
*/
inline T_wrapped& invoke()
{ return visited_.invoke(); }
private:
/** The limited_reference to the bound argument.
*/
limit_reference<T_wrapped> visited_;
};
/** bound_argument object for a bound argument that is passed by bind() or
* returned by bind_return() by const reference, specialized for const reference_wrapper<> types.
* - @e T_wrapped The type of the bound argument.
*/
template <class T_wrapped>
class bound_argument< const_reference_wrapper<T_wrapped> >
{
public:
/** Constructor.
* @param _A_argument The argument to bind.
*/
bound_argument(const const_reference_wrapper<T_wrapped>& _A_argument)
: visited_(unwrap(_A_argument))
{}
/** Retrieve the entity to visit in visit_each().
* @return The const_limited_reference to the bound argument.
*/
inline const const_limit_reference<T_wrapped>& visit() const
{ return visited_; }
/** Retrieve the entity to pass to the bound functor or return.
* @return The bound argument.
*/
inline const T_wrapped& invoke()
{ return visited_.invoke(); }
private:
/** The const_limited_reference to the bound argument.
*/
const_limit_reference<T_wrapped> visited_;
};
/** Implementation of visit_each() specialized for the bound_argument class.
* Call visit_each() on the entity returned by the bound_argument's visit()
* method.
* @e T_action The type of functor to invoke.
* @e T_type The type of bound_argument.
* @param _A_action The functor to invoke.
* @param _A_argument The visited instance.
*/
template <class T_action, class T_type>
void
visit_each(const T_action& _A_action,
const bound_argument<T_type>& _A_argument)
{
visit_each(_A_action, _A_argument.visit());
}
} /* namespace sigc */
#endif /* _SIGC_BOUND_ARGUMENT_H_ */

42
libs/sigc++2/sigc++/adaptors/compose.h
View File

@@ -51,8 +51,10 @@ template <class T_setter, class T_getter>
struct compose1_functor : public adapts<T_setter>
{
typedef typename adapts<T_setter>::adaptor_type adaptor_type;
typedef T_setter setter_type;
typedef T_getter getter_type;
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>
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
@@ -121,7 +123,7 @@ struct compose1_functor : public adapts<T_setter>
: adapts<T_setter>(_A_setter), get_(_A_getter)
{}
T_getter get_; // public, so that visit_each() can access it
getter_type get_; // public, so that visit_each() can access it
};
template <class T_setter, class T_getter>
@@ -143,7 +145,10 @@ template <class T_setter, class T_getter1, class T_getter2>
struct compose2_functor : public adapts<T_setter>
{
typedef typename adapts<T_setter>::adaptor_type adaptor_type;
typedef T_setter setter_type;
typedef T_getter1 getter1_type;
typedef T_getter2 getter2_type;
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<
@@ -223,8 +228,8 @@ struct compose2_functor : public adapts<T_setter>
: 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
getter1_type get1_; // public, so that visit_each() can access it
getter2_type get2_; // public, so that visit_each() can access it
};
template <class T_setter, class T_getter1, class T_getter2>
@@ -232,7 +237,7 @@ 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_()); }
//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::compose1_functor performs a functor on the
* functors stored in the sigc::compose1_functor object.
@@ -243,10 +248,17 @@ 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_);
typedef compose1_functor<T_setter, T_getter> type_functor;
//Note that the AIX compiler needs the actual template types of visit_each to be specified:
typedef typename type_functor::setter_type type_functor1;
visit_each<T_action, type_functor1>(_A_action, _A_target.functor_);
typedef typename type_functor::getter_type type_functor_getter;
visit_each<T_action, type_functor_getter>(_A_action, _A_target.get_);
}
//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::compose2_functor performs a functor on the
* functors stored in the sigc::compose2_functor object.
@@ -257,9 +269,17 @@ 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_);
typedef compose2_functor<T_setter, T_getter1, T_getter2> type_functor;
//Note that the AIX compiler needs the actual template types of visit_each to be specified:
typedef typename type_functor::setter_type type_functor1;
visit_each<T_action, type_functor1>(_A_action, _A_target.functor_);
typedef typename type_functor::getter1_type type_functor_getter1;
visit_each<T_action, type_functor_getter1>(_A_action, _A_target.get1_);
typedef typename type_functor::getter2_type type_functor_getter2;
visit_each<T_action, type_functor_getter2>(_A_action, _A_target.get2_);
}

7
libs/sigc++2/sigc++/adaptors/exception_catch.h
View File

@@ -165,8 +165,7 @@ struct exception_catch_functor : public adapts<T_functor>
: adapts<T_functor>(_A_func), catcher_(_A_catcher)
{}
protected:
T_catcher catcher_;
T_catcher catcher_;
};
template <class T_functor, class T_catcher, class T_return>
@@ -287,7 +286,6 @@ struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_fun
{}
~exception_catch_functor() {}
protected:
T_catcher catcher_;
};
@@ -300,7 +298,8 @@ void exception_catch_functor<T_functor, T_catcher, void>::operator()()
{ this->catcher_(); }
}
//template specialization of visit_each<>(action, functor):
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)

137
libs/sigc++2/sigc++/adaptors/hide.h
View File

@@ -87,7 +87,7 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
*/
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_a1)
operator()(T_arg1)
{ return this->functor_(); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -104,14 +104,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2)
{ 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,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
sun_forte_workaround(T_arg1 _A_a1, T_arg2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); }
#endif
@@ -124,14 +124,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1,T_arg2 _A_a2, T_arg3)
{ 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,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2, T_arg3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
(_A_a1, _A_a2); }
#endif
@@ -145,14 +145,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3, T_arg4)
{ 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,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3, T_arg4)
{ 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
@@ -167,14 +167,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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
@@ -190,14 +190,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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
@@ -214,14 +214,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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
@@ -256,7 +256,7 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
*/
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_a1)
operator()(T_arg1)
{ return this->functor_(); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -273,14 +273,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1, T_arg2 _A_a2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
(_A_a2); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
sun_forte_workaround(T_arg1, T_arg2 _A_a2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
(_A_a2); }
#endif
@@ -293,14 +293,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a2, _A_a3); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a2, _A_a3); }
#endif
@@ -314,14 +314,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a2, _A_a3, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a2, _A_a3, _A_a4); }
#endif
@@ -336,14 +336,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_a2, _A_a3, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_a2, _A_a3, _A_a4, _A_a5); }
#endif
@@ -359,14 +359,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#endif
@@ -383,14 +383,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _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)
sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#endif
@@ -426,14 +426,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2)
{ 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,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
sun_forte_workaround(T_arg1 _A_a1, T_arg2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); }
#endif
@@ -446,14 +446,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a3); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a3); }
#endif
@@ -467,14 +467,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a3, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a3, _A_a4); }
#endif
@@ -489,14 +489,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5); }
#endif
@@ -512,14 +512,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::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_a3, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::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_a3, _A_a4, _A_a5, _A_a6); }
#endif
@@ -536,14 +536,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::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_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::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_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#endif
@@ -580,14 +580,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
{ 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,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
(_A_a1, _A_a2); }
#endif
@@ -601,14 +601,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a4); }
#endif
@@ -623,14 +623,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5); }
#endif
@@ -646,14 +646,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
#endif
@@ -670,14 +670,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::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_a4, _A_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::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_a4, _A_a5, _A_a6, _A_a7); }
#endif
@@ -715,14 +715,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
{ 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,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
{ 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
@@ -737,14 +737,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5); }
#endif
@@ -760,14 +760,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
#endif
@@ -784,14 +784,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::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_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::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_a5, _A_a6, _A_a7); }
#endif
@@ -830,14 +830,14 @@ struct hide_functor <4, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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
@@ -853,14 +853,14 @@ struct hide_functor <4, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
#endif
@@ -877,14 +877,14 @@ struct hide_functor <4, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
#endif
@@ -924,14 +924,14 @@ struct hide_functor <5, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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
@@ -948,14 +948,14 @@ struct hide_functor <5, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
#endif
@@ -996,14 +996,14 @@ struct hide_functor <6, T_functor> : public adapts<T_functor>
*/
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)
operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<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
@@ -1018,6 +1018,7 @@ struct hide_functor <6, T_functor> : public adapts<T_functor>
};
//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::hide_functor performs a functor on the
* functor stored in the sigc::hide_functor object.

55
libs/sigc++2/sigc++/adaptors/lambda/base.h
View File

@@ -3,6 +3,7 @@
#ifndef _SIGC_LAMBDA_BASE_HPP_
#define _SIGC_LAMBDA_BASE_HPP_
#include <sigc++/adaptors/adaptor_trait.h>
#include <sigc++/reference_wrapper.h>
namespace sigc {
@@ -201,72 +202,72 @@ struct lambda_core<T_type, false> : public lambda_base
result_type operator()() const;
template <class T_arg1>
result_type operator ()(T_arg1 _A_1) const
result_type operator ()(T_arg1) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
result_type sun_forte_workaround(T_arg1 _A_1) const
result_type sun_forte_workaround(T_arg1) 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
result_type operator ()(T_arg1,T_arg2) 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
result_type sun_forte_workaround(T_arg1,T_arg2) 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
result_type operator ()(T_arg1,T_arg2,T_arg3) 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
result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3) 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
result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4) 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
result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4) 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
result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) 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
result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) 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
result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) 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
result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) 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
result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) 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
result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -283,6 +284,7 @@ typename lambda_core<T_type, false>::result_type lambda_core<T_type, false>::ope
} /* namespace internal */
//template specialization of visit_each<>(action, functor):
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)
@@ -340,6 +342,7 @@ struct lambda : public internal::lambda_core<T_type>
};
//template specialization of visit_each<>(action, functor):
template <class T_action, class T_type>
void visit_each(const T_action& _A_action,
const lambda<T_type>& _A_target)
@@ -348,12 +351,32 @@ void visit_each(const T_action& _A_action,
}
/// Converts a reference into a lambda object.
/** Converts a reference into a lambda object.
* sigc::var creates a 0-ary functor, returning the value of a referenced variable.
*
* @par Example:
* @code
* int main(int argc, char* argv)
* {
* int data;
* sigc::signal<int> readValue;
*
* readValue.connect(sigc::var(data));
*
* data = 3;
* std::cout << readValue() << std::endl; //Prints 3.
*
* data = 5;
* std::cout << readValue() << std::endl; //Prints 5.
* }
* @endcode
*/
template <class T_type>
lambda<T_type&> var(T_type& v)
{ return lambda<T_type&>(v); }
/// Converts a constant reference into a lambda object.
/** 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); }

3
libs/sigc++2/sigc++/adaptors/lambda/group.h
View File

@@ -223,6 +223,7 @@ lambda_group1<T_functor, T_type1>::operator ()() const
{ return func_(value1_()); }
//template specialization of visit_each<>(action, functor):
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)
@@ -434,6 +435,7 @@ lambda_group2<T_functor, T_type1,T_type2>::operator ()() const
{ return func_(value1_(),value2_()); }
//template specialization of visit_each<>(action, functor):
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)
@@ -692,6 +694,7 @@ lambda_group3<T_functor, T_type1,T_type2,T_type3>::operator ()() const
{ return func_(value1_(),value2_(),value3_()); }
//template specialization of visit_each<>(action, functor):
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)

3
libs/sigc++2/sigc++/adaptors/lambda/operator.h
View File

@@ -750,6 +750,7 @@ lambda_operator<T_action, T_type1, T_type2>::operator ()() const
typename arg2_type::result_type>
(arg1_(), arg2_()); }
//template specialization of visit_each<>(action, functor):
template <class T_action, class T_lambda_action, class T_arg1, class T_arg2>
void visit_each(const T_action& _A_action,
const lambda_operator<T_lambda_action, T_arg1, T_arg2>& _A_target)
@@ -944,6 +945,7 @@ lambda_operator_unary<T_action, T_type>::operator ()() const
typename arg_type::result_type>
(arg_()); }
//template specialization of visit_each<>(action, functor):
template <class T_action, class T_lambda_action, class T_arg>
void visit_each(const T_action& _A_action,
const lambda_operator_unary<T_lambda_action, T_arg>& _A_target)
@@ -1137,6 +1139,7 @@ lambda_operator_convert<T_action, T_type, T_arg>::operator ()() const
typename arg_type::result_type>
(arg_()); }
//template specialization of visit_each<>(action, functor):
template <class T_action, class T_lambda_action, class T_type, class T_arg>
void visit_each(const T_action& _A_action,
const lambda_operator_convert<T_lambda_action, T_type, T_arg>& _A_target)

108
libs/sigc++2/sigc++/adaptors/lambda/select.h
View File

@@ -25,57 +25,57 @@ struct lambda_select1 : public lambda_base
#endif
template <class T_arg1,class T_arg2>
T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
T_arg1 operator ()(T_arg1 _A_1, T_arg2) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3>
T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
T_arg1 operator ()(T_arg1 _A_1,T_arg2 _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; }
T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _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; }
T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
#endif
};
@@ -89,57 +89,57 @@ struct lambda_select2 : public lambda_base
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; }
T_arg2 operator ()(T_arg1, T_arg2 _A_2) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_2; }
T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3>
T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
T_arg2 operator ()(T_arg1 _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; }
T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
T_arg2 sun_forte_workaround(T_arg1 _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; }
T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
T_arg2 operator ()(T_arg1 _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; }
T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
T_arg2 sun_forte_workaround(T_arg1 _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; }
T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
#endif
};
@@ -153,48 +153,48 @@ struct lambda_select3 : public lambda_base
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; }
T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_3; }
T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
T_arg3 operator ()(T_arg1 _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; }
T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
T_arg3 sun_forte_workaround(T_arg1 _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; }
T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
T_arg3 operator ()(T_arg1 _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; }
T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
T_arg3 sun_forte_workaround(T_arg1 _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; }
T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
#endif
};
@@ -208,39 +208,39 @@ struct lambda_select4 : public lambda_base
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; }
T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_4; }
T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
T_arg4 operator ()(T_arg1 _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; }
T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
T_arg4 sun_forte_workaround(T_arg1 _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; }
T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
T_arg4 operator ()(T_arg1 _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; }
T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
T_arg4 sun_forte_workaround(T_arg1 _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; }
T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
#endif
};
@@ -254,30 +254,30 @@ struct lambda_select5 : public lambda_base
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; }
T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_5; }
T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
T_arg5 operator ()(T_arg1 _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; }
T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
T_arg5 sun_forte_workaround(T_arg1 _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; }
T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
T_arg5 operator ()(T_arg1 _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; }
T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
T_arg5 sun_forte_workaround(T_arg1 _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; }
T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
#endif
};
@@ -291,21 +291,21 @@ struct lambda_select6 : public lambda_base
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; }
T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
T_arg6 sun_forte_workaround(T_arg1 _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; }
T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
T_arg6 operator ()(T_arg1 _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; }
T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
T_arg6 sun_forte_workaround(T_arg1 _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; }
T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
#endif
};
@@ -319,12 +319,12 @@ struct lambda_select7 : public lambda_base
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; }
T_arg7 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
T_arg7 sun_forte_workaround(T_arg1 _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; }
T_arg7 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
#endif
};

31
libs/sigc++2/sigc++/adaptors/retype.h
View File

@@ -81,7 +81,7 @@ struct retype_functor
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_a1)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
((T_type1)_A_a1);
(static_cast<T_type1>(_A_a1));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -89,7 +89,7 @@ struct retype_functor
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_a1)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
((T_type1)_A_a1);
(static_cast<T_type1>(_A_a1));
}
#endif
@@ -97,7 +97,7 @@ struct retype_functor
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 type_trait<T_type1>::take,typename type_trait<T_type2>::take>
((T_type1)_A_a1,(T_type2)_A_a2);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -105,7 +105,7 @@ struct retype_functor
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
((T_type1)_A_a1,(T_type2)_A_a2);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2));
}
#endif
@@ -113,7 +113,7 @@ struct retype_functor
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 type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -121,7 +121,7 @@ struct retype_functor
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3));
}
#endif
@@ -129,7 +129,7 @@ struct retype_functor
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 type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -137,7 +137,7 @@ struct retype_functor
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4));
}
#endif
@@ -145,7 +145,7 @@ struct retype_functor
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 type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename 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);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -153,7 +153,7 @@ struct retype_functor
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename 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);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5));
}
#endif
@@ -161,7 +161,7 @@ struct retype_functor
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 type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename 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);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -169,7 +169,7 @@ struct retype_functor
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename 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);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6));
}
#endif
@@ -177,7 +177,7 @@ struct retype_functor
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 type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename 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);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -185,7 +185,7 @@ struct retype_functor
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename 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);
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7));
}
#endif
@@ -203,7 +203,8 @@ typename retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_typ
retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
{ return this->functor_(); }
//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::retype_functor performs a functor on the
* functor stored in the sigc::retype_functor object.

3
libs/sigc++2/sigc++/adaptors/retype_return.h
View File

@@ -264,7 +264,8 @@ template <class T_functor>
void retype_return_functor<void, T_functor>::operator()()
{ this->functor_(); }
//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::retype_return_functor performs a functor on the
* functor stored in the sigc::retype_return_functor object.

2
libs/sigc++2/sigc++/connection.cc
View File

@@ -103,7 +103,7 @@ void connection::set_slot(slot_base* sl)
void* connection::notify(void* data)
{
connection* self = (connection*)data;
connection* self = reinterpret_cast<connection*>(data);
self->slot_ = 0;
return 0;
}

609
libs/sigc++2/sigc++/functors/mem_fun.h
View File

File diff suppressed because it is too large Load Diff

120
libs/sigc++2/sigc++/functors/slot.h
View File

@@ -54,7 +54,7 @@ struct typed_slot_rep : public slot_rep
*/
static void* destroy(void* data)
{
self* self_ = static_cast<self*>((slot_rep*)data);
self* self_ = static_cast<self*>(reinterpret_cast<slot_rep*>(data));
self_->call_ = 0;
self_->destroy_ = 0;
visit_each_type<trackable*>(slot_do_unbind(self_), self_->functor_);
@@ -73,8 +73,8 @@ struct typed_slot_rep : public slot_rep
*/
static void* dup(void* data)
{
slot_rep* rep_ = (slot_rep*)data;
return static_cast<slot_rep*>(new self(*static_cast<self*>(rep_)));
slot_rep* a_rep = reinterpret_cast<slot_rep*>(data);
return static_cast<slot_rep*>(new self(*static_cast<self*>(a_rep)));
}
};
@@ -437,7 +437,7 @@ public:
inline T_return operator()() const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_);
return T_return();
}
@@ -449,7 +449,10 @@ public:
template <class T_functor>
slot0(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call0<T_functor, T_return>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call0<T_functor, T_return>::address();
}
slot0(const slot0& src)
: slot_base(src) {}
@@ -509,7 +512,7 @@ public:
inline T_return operator()(arg1_type_ _A_a1) const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1);
return T_return();
}
@@ -521,7 +524,10 @@ public:
template <class T_functor>
slot1(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call1<T_functor, T_return, T_arg1>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call1<T_functor, T_return, T_arg1>::address();
}
slot1(const slot1& src)
: slot_base(src) {}
@@ -584,7 +590,7 @@ public:
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2) const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2);
return T_return();
}
@@ -596,7 +602,10 @@ public:
template <class T_functor>
slot2(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call2<T_functor, T_return, T_arg1,T_arg2>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call2<T_functor, T_return, T_arg1,T_arg2>::address();
}
slot2(const slot2& src)
: slot_base(src) {}
@@ -662,7 +671,7 @@ public:
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3) const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3);
return T_return();
}
@@ -674,7 +683,10 @@ public:
template <class T_functor>
slot3(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call3<T_functor, T_return, T_arg1,T_arg2,T_arg3>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call3<T_functor, T_return, T_arg1,T_arg2,T_arg3>::address();
}
slot3(const slot3& src)
: slot_base(src) {}
@@ -743,7 +755,7 @@ public:
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4) const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4);
return T_return();
}
@@ -755,7 +767,10 @@ public:
template <class T_functor>
slot4(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call4<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call4<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4>::address();
}
slot4(const slot4& src)
: slot_base(src) {}
@@ -827,7 +842,7 @@ public:
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5) const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
return T_return();
}
@@ -839,7 +854,10 @@ public:
template <class T_functor>
slot5(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call5<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call5<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::address();
}
slot5(const slot5& src)
: slot_base(src) {}
@@ -914,7 +932,7 @@ public:
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5,arg6_type_ _A_a6) const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
return T_return();
}
@@ -926,7 +944,10 @@ public:
template <class T_functor>
slot6(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call6<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call6<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::address();
}
slot6(const slot6& src)
: slot_base(src) {}
@@ -1004,7 +1025,7 @@ public:
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5,arg6_type_ _A_a6,arg7_type_ _A_a7) const
{
if (!empty() && !blocked())
return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
return T_return();
}
@@ -1016,7 +1037,10 @@ public:
template <class T_functor>
slot7(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
{ rep_->call_ = internal::slot_call7<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::address(); }
{
//The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
slot_base::rep_->call_ = internal::slot_call7<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::address();
}
slot7(const slot7& src)
: slot_base(src) {}
@@ -1078,17 +1102,19 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
/** Convenience wrapper for the numbered sigc::slot0 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
* template for 0 argument(s).
* template for 0 argument(s), specialized for different numbers of arguments
* This is possible because the template has default (nil) template types.
*/
template <class T_return>
class slot <T_return>
class slot <T_return, nil, nil, nil, nil, nil, nil, nil>
: public slot0<T_return>
{
public:
@@ -1104,16 +1130,18 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
/** Convenience wrapper for the numbered sigc::slot1 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
* template for 1 argument(s).
* template for 1 argument(s), specialized for different numbers of arguments
* This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1>
class slot <T_return, T_arg1>
class slot <T_return, T_arg1, nil, nil, nil, nil, nil, nil>
: public slot1<T_return, T_arg1>
{
public:
@@ -1129,16 +1157,18 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
/** Convenience wrapper for the numbered sigc::slot2 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
* template for 2 argument(s).
* template for 2 argument(s), specialized for different numbers of arguments
* This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2>
class slot <T_return, T_arg1,T_arg2>
class slot <T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
: public slot2<T_return, T_arg1,T_arg2>
{
public:
@@ -1154,16 +1184,18 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
/** Convenience wrapper for the numbered sigc::slot3 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
* template for 3 argument(s).
* template for 3 argument(s), specialized for different numbers of arguments
* This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
class slot <T_return, T_arg1,T_arg2,T_arg3>
class slot <T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
: public slot3<T_return, T_arg1,T_arg2,T_arg3>
{
public:
@@ -1179,16 +1211,18 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
/** Convenience wrapper for the numbered sigc::slot4 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
* template for 4 argument(s).
* template for 4 argument(s), specialized for different numbers of arguments
* This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4>
class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
: public slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
{
public:
@@ -1204,16 +1238,18 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
/** Convenience wrapper for the numbered sigc::slot5 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
* template for 5 argument(s).
* template for 5 argument(s), specialized for different numbers of arguments
* This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>
: public slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
{
public:
@@ -1229,16 +1265,18 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
/** Convenience wrapper for the numbered sigc::slot6 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
* template for 6 argument(s).
* template for 6 argument(s), specialized for different numbers of arguments
* This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
: public slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
{
public:
@@ -1254,7 +1292,7 @@ public:
: parent_type(_A_func) {}
slot(const slot& src)
: parent_type((const parent_type&)src) {}
: parent_type(reinterpret_cast<const parent_type&>(src)) {}
};

18
libs/sigc++2/sigc++/functors/slot_base.cc
View File

@@ -49,15 +49,19 @@ void slot_rep::disconnect()
parent_ = 0; // Just a precaution.
(cleanup_)(data_); // Notify the parent (might lead to destruction of this!).
}
else
call_ = 0;
}
//static
void* slot_rep::notify(void* data)
{
slot_rep* self_ = (slot_rep*)data;
slot_rep* self_ = reinterpret_cast<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;
}
@@ -78,7 +82,17 @@ slot_base::slot_base(const slot_base& src)
blocked_(src.blocked_)
{
if (src.rep_)
rep_ = src.rep_->dup();
{
//Check call_ so we can ignore invalidated slots.
//Otherwise, destroyed bound reference parameters (whose destruction caused the slot's invalidation) may be used during dup().
//Note: I'd prefer to check somewhere during dup(). murrayc.
if (src.rep_->call_)
rep_ = src.rep_->dup();
else
{
*this = slot_base(); //Return the default invalid slot.
}
}
}
slot_base::~slot_base()

6
libs/sigc++2/sigc++/functors/slot_base.h
View File

@@ -101,7 +101,7 @@ struct SIGC_API slot_rep : public trackable
* @return A deep copy of the slot_rep object.
*/
inline slot_rep* dup() const
{ return (slot_rep*)(*dup_)(const_cast<slot_rep*>(this)); }
{ return reinterpret_cast<slot_rep*>((*dup_)(const_cast<slot_rep*>(this))); }
/** Set the parent with a callback.
* slots have one parent exclusively.
@@ -298,7 +298,9 @@ public:
*/
void disconnect();
protected:
//The Tru64 and Solaris Forte 5.5 compilers needs this operator=() to be public. I'm not sure why, or why it needs to be protected usually. murrayc.
//See bug #168265.
//protected:
/** Overrides this slot making a copy from another slot.
* @param src The slot from which to make a copy.
* @return @p this.

455
libs/sigc++2/sigc++/limit_reference.h Normal file
View File

@@ -0,0 +1,455 @@
// -*- c++ -*-
/* Do not edit! -- generated file */
#ifndef _SIGC_MACROS_LIMIT_REFERENCEHM4_
#define _SIGC_MACROS_LIMIT_REFERENCEHM4_
#include <sigc++/type_traits.h>
#include <sigc++/trackable.h>
namespace sigc {
/** A limit_reference<Foo> object stores a reference (Foo&), but make sure that,
* if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
* sigc::trackable reference instead of the derived reference. This avoids use of
* a reference to the derived type when the derived destructor has run. That can be
* a problem when using virtual inheritance.
*
* If Foo inherits from trackable then both the derived reference and the
* sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
* reference without doing an implicit conversion. To retrieve the derived reference
* (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
* reference (so that you can call visit_each() on it), you use visit().
*
* If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
* derived reference.
*
* This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
* and, with mem_fun(), the reference to the handling object.
*
* - @e T_type The type of the reference.
*/
template <class T_type,
bool I_derives_trackable =
is_base_and_derived<trackable, T_type>::value>
class limit_reference
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
limit_reference(T_type& _A_target)
: visited(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const T_type& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline T_type& invoke() const
{ return visited; }
private:
/** The reference.
*/
T_type& visited;
};
/** limit_reference object for a class that derives from trackable.
* - @e T_type The type of the reference.
*/
template <class T_type>
class limit_reference<T_type, true>
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
limit_reference(T_type& _A_target)
: visited(_A_target),
invoked(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const trackable& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline T_type& invoke() const
{ return invoked; }
private:
/** The trackable reference.
*/
trackable& visited;
/** The reference.
*/
T_type& invoked;
};
/** Implementation of visit_each() specialized for the limit_reference
* class, to call visit_each() on the entity returned by the limit_reference's
* visit() method.
* - @e T_action The type of functor to invoke.
* - @e T_type The type of the reference.
* @param _A_action The functor to invoke.
* @param _A_argument The visited instance.
*/
template <class T_action, class T_type, bool I_derives_trackable>
void
visit_each(const T_action& _A_action,
const limit_reference<T_type, I_derives_trackable>& _A_target)
{
visit_each(_A_action, _A_target.visit());
}
/** A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
* if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
* sigc::trackable reference instead of the derived reference. This avoids use of
* a reference to the derived type when the derived destructor has run. That can be
* a problem when using virtual inheritance.
*
* If Foo inherits from trackable then both the derived reference and the
* sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
* reference without doing an implicit conversion. To retrieve the derived reference
* (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
* reference (so that you can call visit_each() on it), you use visit().
*
* If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
* derived reference.
*
* This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
* and, with mem_fun(), the reference to the handling object.
*
* - @e T_type The type of the reference.
*/
template <class T_type,
bool I_derives_trackable =
is_base_and_derived<trackable, T_type>::value>
class const_limit_reference
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
const_limit_reference(const T_type& _A_target)
: visited(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const T_type& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline const T_type& invoke() const
{ return visited; }
private:
/** The reference.
*/
const T_type& visited;
};
/** const_limit_reference object for a class that derives from trackable.
* - @e T_type The type of the reference.
*/
template <class T_type>
class const_limit_reference<T_type, true>
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
const_limit_reference(const T_type& _A_target)
: visited(_A_target),
invoked(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const trackable& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline const T_type& invoke() const
{ return invoked; }
private:
/** The trackable reference.
*/
const trackable& visited;
/** The reference.
*/
const T_type& invoked;
};
/** Implementation of visit_each() specialized for the const_limit_reference
* class, to call visit_each() on the entity returned by the const_limit_reference's
* visit() method.
* - @e T_action The type of functor to invoke.
* - @e T_type The type of the reference.
* @param _A_action The functor to invoke.
* @param _A_argument The visited instance.
*/
template <class T_action, class T_type, bool I_derives_trackable>
void
visit_each(const T_action& _A_action,
const const_limit_reference<T_type, I_derives_trackable>& _A_target)
{
visit_each(_A_action, _A_target.visit());
}
/** A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
* if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
* sigc::trackable reference instead of the derived reference. This avoids use of
* a reference to the derived type when the derived destructor has run. That can be
* a problem when using virtual inheritance.
*
* If Foo inherits from trackable then both the derived reference and the
* sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
* reference without doing an implicit conversion. To retrieve the derived reference
* (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
* reference (so that you can call visit_each() on it), you use visit().
*
* If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
* derived reference.
*
* This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
* and, with mem_fun(), the reference to the handling object.
*
* - @e T_type The type of the reference.
*/
template <class T_type,
bool I_derives_trackable =
is_base_and_derived<trackable, T_type>::value>
class volatile_limit_reference
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
volatile_limit_reference(T_type& _A_target)
: visited(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const T_type& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline volatile T_type& invoke() const
{ return visited; }
private:
/** The reference.
*/
T_type& visited;
};
/** volatile_limit_reference object for a class that derives from trackable.
* - @e T_type The type of the reference.
*/
template <class T_type>
class volatile_limit_reference<T_type, true>
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
volatile_limit_reference(T_type& _A_target)
: visited(_A_target),
invoked(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const trackable& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline volatile T_type& invoke() const
{ return invoked; }
private:
/** The trackable reference.
*/
trackable& visited;
/** The reference.
*/
T_type& invoked;
};
/** Implementation of visit_each() specialized for the volatile_limit_reference
* class, to call visit_each() on the entity returned by the volatile_limit_reference's
* visit() method.
* - @e T_action The type of functor to invoke.
* - @e T_type The type of the reference.
* @param _A_action The functor to invoke.
* @param _A_argument The visited instance.
*/
template <class T_action, class T_type, bool I_derives_trackable>
void
visit_each(const T_action& _A_action,
const volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
{
visit_each(_A_action, _A_target.visit());
}
/** A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
* if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
* sigc::trackable reference instead of the derived reference. This avoids use of
* a reference to the derived type when the derived destructor has run. That can be
* a problem when using virtual inheritance.
*
* If Foo inherits from trackable then both the derived reference and the
* sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
* reference without doing an implicit conversion. To retrieve the derived reference
* (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
* reference (so that you can call visit_each() on it), you use visit().
*
* If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
* derived reference.
*
* This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
* and, with mem_fun(), the reference to the handling object.
*
* - @e T_type The type of the reference.
*/
template <class T_type,
bool I_derives_trackable =
is_base_and_derived<trackable, T_type>::value>
class const_volatile_limit_reference
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
const_volatile_limit_reference(const T_type& _A_target)
: visited(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const T_type& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline const volatile T_type& invoke() const
{ return visited; }
private:
/** The reference.
*/
const T_type& visited;
};
/** const_volatile_limit_reference object for a class that derives from trackable.
* - @e T_type The type of the reference.
*/
template <class T_type>
class const_volatile_limit_reference<T_type, true>
{
public:
/** Constructor.
* @param _A_target The reference to limit.
*/
const_volatile_limit_reference(const T_type& _A_target)
: visited(_A_target),
invoked(_A_target)
{}
/** Retrieve the entity to visit for visit_each().
* Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
* @return The reference.
*/
inline const trackable& visit() const
{ return visited; }
/** Retrieve the reference.
* This is always a reference to the derived instance.
* @return The reference.
*/
inline const volatile T_type& invoke() const
{ return invoked; }
private:
/** The trackable reference.
*/
const trackable& visited;
/** The reference.
*/
const T_type& invoked;
};
/** Implementation of visit_each() specialized for the const_volatile_limit_reference
* class, to call visit_each() on the entity returned by the const_volatile_limit_reference's
* visit() method.
* - @e T_action The type of functor to invoke.
* - @e T_type The type of the reference.
* @param _A_action The functor to invoke.
* @param _A_argument The visited instance.
*/
template <class T_action, class T_type, bool I_derives_trackable>
void
visit_each(const T_action& _A_action,
const const_volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
{
visit_each(_A_action, _A_target.visit());
}
} /* namespace sigc */
#endif /* _SIGC_MACROS_LIMIT_REFERENCEHM4_ */

8
libs/sigc++2/sigc++/reference_wrapper.h
View File

@@ -97,14 +97,6 @@ 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; }

57
libs/sigc++2/sigc++/retype.h
View File

@@ -23,98 +23,98 @@ struct retype_slot_functor
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));
(static_cast<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));
(static_cast<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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
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));
(static_cast<T_type1>(_A_a1),static_cast<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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#endif
@@ -144,98 +144,98 @@ struct retype_slot_functor<T_functor, void, T_type1,T_type2,T_type3,T_type4,T_ty
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));
(static_cast<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));
(static_cast<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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
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));
(static_cast<T_type1>(_A_a1),static_cast<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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
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));
(static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#endif
@@ -250,6 +250,7 @@ void retype_slot_functor<T_functor, void, T_type1,T_type2,T_type3,T_type4,T_type
{ this->functor_(); }
//template specialization of visit_each<>(action, 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)

423
libs/sigc++2/sigc++/signal.h
View File

@@ -11,11 +11,13 @@
#include <sigc++/functors/slot.h>
#include <sigc++/functors/mem_fun.h>
// TODO: This should have its own test.
//SIGC_TYPEDEF_REDEFINE_ALLOWED:
// TODO: This should have its own test, but I can not create one that gives the error instead of just a warning. murrayc.
// I have just used this because there is a correlation between these two problems.
#ifdef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
//Compilers, such as SUN Forte C++, that do not allow this also often
//Compilers, such as older versions of SUN Forte C++, that do not allow this also often
//do not allow a typedef to have the same name as a class in the typedef's definition.
//For Sun Forte CC 5.7 (SUN Workshop 10), comment this out to fix the build.
#define SIGC_TYPEDEF_REDEFINE_ALLOWED 1
#endif
@@ -71,7 +73,7 @@ struct slot_iterator
return *this;
}
slot_iterator& operator--(int)
slot_iterator operator--(int)
{
slot_iterator __tmp(*this);
--i_;
@@ -137,7 +139,7 @@ struct slot_const_iterator
return *this;
}
slot_const_iterator& operator--(int)
slot_const_iterator operator--(int)
{
slot_const_iterator __tmp(*this);
--i_;
@@ -171,8 +173,20 @@ struct slot_list
typedef slot_iterator<slot_type> iterator;
typedef slot_const_iterator<slot_type> const_iterator;
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
#else
typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
int, int&, int*, ptrdiff_t> reverse_iterator;
typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
int, const int&, const int*, ptrdiff_t> const_reverse_iterator;
#endif /* SIGC_HAVE_SUN_REVERSE_ITERATOR */
slot_list()
: list_(0) {}
@@ -307,7 +321,7 @@ struct slot_iterator_buf
return *this;
}
slot_iterator_buf& operator--(int)
slot_iterator_buf operator--(int)
{
slot_iterator_buf __tmp(*this);
--i_;
@@ -383,7 +397,7 @@ struct slot_iterator_buf<T_emitter, void>
return *this;
}
slot_iterator_buf& operator--(int)
slot_iterator_buf operator--(int)
{
slot_iterator_buf __tmp(*this);
--i_;
@@ -439,10 +453,11 @@ struct signal_emit0
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self ;
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
};
@@ -468,21 +483,32 @@ struct signal_emit0<T_return, nil>
*/
static result_type emit(signal_impl* impl)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
}
}
return r_;
}
};
@@ -509,8 +535,9 @@ struct signal_emit0<void, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -563,10 +590,11 @@ struct signal_emit1
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self (_A_a1);
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
@@ -595,21 +623,32 @@ struct signal_emit1<T_return, T_arg1, nil>
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
}
}
return r_;
}
};
@@ -638,8 +677,9 @@ struct signal_emit1<void, T_arg1, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -693,10 +733,11 @@ struct signal_emit2
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2);
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
@@ -727,21 +768,32 @@ struct signal_emit2<T_return, T_arg1,T_arg2, nil>
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
}
}
return r_;
}
};
@@ -771,8 +823,9 @@ struct signal_emit2<void, T_arg1,T_arg2, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -827,10 +880,11 @@ struct signal_emit3
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3);
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
@@ -863,21 +917,32 @@ struct signal_emit3<T_return, T_arg1,T_arg2,T_arg3, nil>
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
}
}
return r_;
}
};
@@ -908,8 +973,9 @@ struct signal_emit3<void, T_arg1,T_arg2,T_arg3, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -965,10 +1031,11 @@ struct signal_emit4
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4);
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
@@ -1003,21 +1070,32 @@ struct signal_emit4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil>
*/
static result_type emit(signal_impl* impl, 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)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
}
}
return r_;
}
};
@@ -1049,8 +1127,9 @@ struct signal_emit4<void, T_arg1,T_arg2,T_arg3,T_arg4, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -1107,10 +1186,11 @@ struct signal_emit5
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
@@ -1147,21 +1227,32 @@ struct signal_emit5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil>
*/
static result_type emit(signal_impl* impl, 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)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
}
}
return r_;
}
};
@@ -1194,8 +1285,9 @@ struct signal_emit5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -1253,10 +1345,11 @@ struct signal_emit6
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
@@ -1295,21 +1388,32 @@ struct signal_emit6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
*/
static result_type emit(signal_impl* impl, 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)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
}
}
return r_;
}
};
@@ -1343,8 +1447,9 @@ struct signal_emit6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -1403,10 +1508,11 @@ struct signal_emit7
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
slot_iterator_buf_type(impl->slots_.end(), &self));
return accumulator(slot_iterator_buf_type(slots.begin(), &self),
slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
@@ -1447,21 +1553,32 @@ struct signal_emit7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7,
*/
static result_type emit(signal_impl* impl, 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)
{
if (!impl || impl->slots_.empty()) return T_return();
iterator_type it = impl->slots_.begin();
for (; it != impl->slots_.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
if (!impl || impl->slots_.empty())
return T_return();
signal_exec exec(impl);
T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
for (++it; it != impl->slots_.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
}
T_return r_ = T_return();
//Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
//This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
{
temp_slot_list slots(impl->slots_);
iterator_type it = slots.begin();
for (; it != slots.end(); ++it)
if (!it->empty() && !it->blocked()) break;
if (it == slots.end())
return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
for (++it; it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
}
}
return r_;
}
};
@@ -1496,8 +1613,9 @@ struct signal_emit7<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, nil>
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
temp_slot_list slots(impl->slots_);
for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
@@ -2540,13 +2658,14 @@ public:
};
/** Convenience wrapper for the numbered sigc::signal0 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 0 argument(s).
*/
template <class T_return>
class signal <T_return>
class signal <T_return, nil,nil,nil,nil,nil,nil,nil>
: public signal0<T_return, nil>
{
public:
@@ -2570,13 +2689,14 @@ public:
: signal0<T_return, nil>(src) {}
};
/** Convenience wrapper for the numbered sigc::signal1 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 1 argument(s).
*/
template <class T_return, class T_arg1>
class signal <T_return, T_arg1>
class signal <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
: public signal1<T_return, T_arg1, nil>
{
public:
@@ -2600,13 +2720,14 @@ public:
: signal1<T_return, T_arg1, nil>(src) {}
};
/** Convenience wrapper for the numbered sigc::signal2 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 2 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2>
class signal <T_return, T_arg1,T_arg2>
class signal <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
: public signal2<T_return, T_arg1,T_arg2, nil>
{
public:
@@ -2630,13 +2751,14 @@ public:
: signal2<T_return, T_arg1,T_arg2, nil>(src) {}
};
/** Convenience wrapper for the numbered sigc::signal3 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 3 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
class signal <T_return, T_arg1,T_arg2,T_arg3>
class signal <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
: public signal3<T_return, T_arg1,T_arg2,T_arg3, nil>
{
public:
@@ -2660,13 +2782,14 @@ public:
: signal3<T_return, T_arg1,T_arg2,T_arg3, nil>(src) {}
};
/** Convenience wrapper for the numbered sigc::signal4 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 4 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4>
class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
: public signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil>
{
public:
@@ -2690,13 +2813,14 @@ public:
: signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil>(src) {}
};
/** Convenience wrapper for the numbered sigc::signal5 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 5 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
: public signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil>
{
public:
@@ -2720,13 +2844,14 @@ public:
: signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil>(src) {}
};
/** Convenience wrapper for the numbered sigc::signal6 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 6 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
: public signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
{
public:

3
libs/sigc++2/sigc++/signal_base.cc
View File

@@ -68,6 +68,7 @@ signal_impl::iterator_type signal_impl::insert(signal_impl::iterator_type i, con
void signal_impl::sweep()
{
deferred_ = false;
iterator_type i = slots_.begin();
while (i != slots_.end())
if ((*i).empty())
@@ -78,7 +79,7 @@ void signal_impl::sweep()
void* signal_impl::notify(void* d)
{
signal_impl* self = (signal_impl*)d;
signal_impl* self = reinterpret_cast<signal_impl*>(d);
if (self->exec_count_ == 0)
self->sweep();
else // This is occuring during signal emission.

45
libs/sigc++2/sigc++/signal_base.h
View File

@@ -44,8 +44,9 @@ namespace internal
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;
typedef std::list<slot_base> slot_list;
typedef slot_list::iterator iterator_type;
typedef slot_list::const_iterator const_iterator_type;
signal_impl();
@@ -160,6 +161,40 @@ struct SIGC_API signal_exec
{ sig_->unreference_exec(); }
};
/** Temporary slot list used during signal emission.
* Through evolution this class is slightly misnamed. It is now
* an index into the slot_list passed into it. It simply keeps track
* of where the end of this list was at construction, and pretends that's
* the end of your list. This way you may connect during emittion without
* inadvertently entering an infinite loop, as well as make other
* modifications to the slot_list at your own risk.
*/
struct temp_slot_list
{
typedef signal_impl::slot_list slot_list;
typedef signal_impl::iterator_type iterator;
typedef signal_impl::const_iterator_type const_iterator;
temp_slot_list(slot_list &slots) : slots_(slots)
{
placeholder = slots_.insert(slots_.end(), slot_base());
}
~temp_slot_list()
{
slots_.erase(placeholder);
}
iterator begin() { return slots_.begin(); }
iterator end() { return placeholder; }
const_iterator begin() const { return slots_.begin(); }
const_iterator end() const { return placeholder; }
private:
slot_list &slots_;
slot_list::iterator placeholder;
};
} /* namespace internal */
@@ -228,13 +263,16 @@ struct SIGC_API signal_base : public trackable
protected:
typedef internal::signal_impl::iterator_type iterator_type;
/** Adds a slot at the bottom of the list of slots.
/** Adds a slot at the end of the list of slots.
* With connect(), slots can also be added during signal emission.
* In this case, they won't be executed until the next emission occurs.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
*/
iterator_type connect(const slot_base& slot_);
/** Adds a slot at the given position into the list of slots.
* Note that this function does not work during signal emission!
* @param i An iterator indicating the position where @e slot_ should be inserted.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
@@ -242,6 +280,7 @@ protected:
iterator_type insert(iterator_type i, const slot_base& slot_);
/** Removes the slot at the given position from the list of slots.
* Note that this function does not work during signal emission!
* @param i An iterator pointing to the slot to be removed.
* @return An iterator pointing to the slot in the list after the one removed.
*/

3
libs/sigc++2/sigc++/trackable.cc
View File

@@ -20,6 +20,9 @@
#include <sigc++/trackable.h>
#include <iostream>
SIGC_USING_STD(ostream)
using namespace std;
namespace sigc

70
libs/sigc++2/sigc++/type_traits.h
View File

@@ -19,7 +19,8 @@
#ifndef _SIGC_TYPE_TRAIT_H_
#define _SIGC_TYPE_TRAIT_H_
#include <sigc++/reference_wrapper.h>
#include <sigc++config.h> //To get SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
namespace sigc {
@@ -59,24 +60,6 @@ struct type_trait<const T_type&>
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>
{
@@ -87,9 +70,27 @@ struct type_trait<void>
};
/** From Esa Pulkkin:
// From Esa Pulkkin:
/**
* Compile-time determination of base-class relationship in C++
* (adapted to match the syntax of boost's type_traits library).
*
* Use this to provide a template specialization for a set of types.
* For instance,
*
* template < class T_thing, bool Tval_derives_from_something = sigc::is_base_and_derived<Something, T_thing>::value >
* class TheTemplate
* {
* //Standard implementation.
* }
*
* //Specialization for T_things that derive from Something (Tval_derives_from_something is true)
* template <class T_thing>
* class TheTemplate<T_thing, true>
* {
* T_thing thing;
thing.method_that_is_in_something();
* }
*/
template <class T_base, class T_derived>
struct is_base_and_derived
@@ -99,15 +100,40 @@ private:
char memory[64];
};
struct test {
#ifndef SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
//Allow the internal inner class to access the other (big) inner
//class. The Tru64 compiler needs this. murrayc.
friend struct internal_class;
//Certain compilers, notably GCC 3.2, require these functions to be inside an inner class.
struct internal_class
{
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(internal_class::is_base_class_(reinterpret_cast<typename type_trait<T_derived>::pointer>(0))) ==
sizeof(char);
#else //SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
//The AIX xlC compiler does not like these 2 functions being in the inner class.
//It says "The incomplete type "test" must not be used as a qualifier.
//It does not seem necessary anyway. murrayc.
static big is_base_class_(...);
static char is_base_class_(typename type_trait<T_base>::pointer);
public:
static const bool value =
sizeof(is_base_class_(reinterpret_cast<typename type_trait<T_derived>::pointer>(0))) ==
sizeof(char);
#endif //SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
void avoid_gcc3_warning_(); //Not implemented. g++ 3.3.5 (but not 3.3.4, and not 3.4) warn that there are no public methods, even though there is a public variable.
};
template <class T_base>

98
libs/sigc++2/sigc++/visit_each.h
View File

@@ -26,52 +26,83 @@ namespace sigc {
namespace internal {
//This should really be an inner class of limit_derived_target, without the T_limit template type,
//But the SUN CC 5.7 (not earlier versions) compiler finds it ambiguous when we specify a particular specialization of it.
//and does not seem to allow us to tell it explicitly that it's an inner class.
template <bool I_derived, class T_type, class T_limit>
struct with_type;
//Specialization for I_derived = false
template <class T_type, class T_limit> struct
with_type<false, T_type, T_limit>
{
static void execute_(const T_type&, const T_limit&) {}
};
//Specialization for I_derived = true
template <class T_type, class T_limit>
struct with_type<true, T_type, T_limit>
{
static void execute_(const T_type& _A_type, const T_limit& _A_action)
{ _A_action.action_(_A_type); }
};
/// Helper struct for visit_each_type().
template <class T_target, class T_action>
struct limit_derived_target
{
typedef limit_derived_target<T_target, T_action> T_self;
template <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); }
{
with_type<is_base_and_derived<T_target, T_type>::value, T_type, T_self>::execute_(_A_type, *this);
}
limit_derived_target(const T_action& _A_action): action_(_A_action) {}
limit_derived_target(const T_action& _A_action)
: action_(_A_action)
{}
T_action action_;
};
/// Helper struct for visit_each_type().
// Specialization for T_target pointer types, to provide a slightly different execute_() implementation.
template <bool I_derived, class T_type, class T_limit>
struct with_type_pointer;
//Specialization for I_derived = false
template <class T_type, class T_limit>
struct with_type_pointer<false, T_type, T_limit>
{
static void execute_(const T_type&, const T_limit&) {}
};
//Specialization for I_derived = true
template <class T_type, class T_limit>
struct with_type_pointer<true, T_type, T_limit>
{
static void execute_(const T_type& _A_type, const T_limit& _A_action)
{ _A_action.action_(&_A_type); }
};
template <class T_target, class T_action>
struct limit_derived_target<T_target*, T_action>
{
typedef limit_derived_target<T_target*, T_action> T_self;
template <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); }
{
with_type_pointer<is_base_and_derived<T_target, T_type>::value, T_type, T_self>::execute_(_A_type, *this);
}
limit_derived_target(const T_action& _A_action): action_(_A_action) {}
limit_derived_target(const T_action& _A_action)
: action_(_A_action)
{}
T_action action_;
};
@@ -120,8 +151,23 @@ void visit_each(const T_action& _A_action, const T_functor& _A_functor)
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);
typedef internal::limit_derived_target<T_type, T_action> type_limited_action;
type_limited_action limited_action(_A_action);
//specifying the types of the template specialization prevents disconnection of bound trackable references (such as with sigc::ref()),
//probably because the visit_each<> specializations take various different template types,
//in various sequences, and we are probably specifying only a subset of them with this.
//
//But this is required by the AIX (and maybe IRIX MipsPro and Tru64) compilers.
//I guess that sigc::ref() therefore does not work on those platforms. murrayc
//visit_each<type_limited_action, T_functor>(limited_action, _A_functor);
//g++ (even slightly old ones) is our primary platform, so we could use the non-crashing version.
//However, the expliict version also fixes a crash in a slightl more common case: http://bugzilla.gnome.org/show_bug.cgi?id=169225
//Users (and distributors) of libsigc++ on AIX (and maybe IRIX MipsPro and Tru64) do
//need to use the version above instead, to allow compilation.
visit_each(limited_action, _A_functor);
}
} /* namespace sigc */

86
libs/sigc++2/sigc++config.h.in
View File

@@ -1,10 +1,80 @@
/* sigc++config.h.in. (Generated manually.) */
/* configure checks */
#undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
#undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
#ifndef _SIGCXX_CONFIG_H
#define _SIGCXX_CONFIG_H
/* 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
// Detect common platforms
#if defined(_WIN32)
// Win32 compilers have a lot of variation
#if defined(_MSC_VER)
#define SIGC_MSC
#define SIGC_WIN32
#define SIGC_DLL
#elif defined(__CYGWIN__)
#define SIGC_CONFIGURE
#elif defined(__MINGW32__)
#define SIGC_WIN32
#define SIGC_CONFIGURE
#else
//The Tru64 compiler complains about this "unrecognized preprocessing directive", but it should never get this far anyway.
//#warning "libsigc++ config: Unknown win32 architecture (send me gcc --dumpspecs or equiv)"
#endif
#else
#define SIGC_CONFIGURE
#endif /* _WIN32 */
#ifdef SIGC_CONFIGURE
// configure checks
#undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
#undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
#undef SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
#undef SIGC_HAVE_NAMESPACE_STD
#undef SIGC_HAVE_SUN_REVERSE_ITERATOR
#undef SIGC_TYPEDEF_REDEFINE_ALLOWED
// platform specific macros
// #define LIBSIGC_DISABLE_DEPRECATED
// #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY
#endif /* SIGC_CONFIGURE */
#ifdef SIGC_MSC
// MS VC7 Warning 4251 says that the classes to any member objects in an
// exported class must be also be exported. Some of the libsigc++
// template classes contain std::list members. MS KB article 168958 says
// that it's not possible to export a std::list instantiation due to some
// wacky class nesting issues, so our only options are to ignore the
// warning or to modify libsigc++ to remove the std::list dependency.
// AFAICT, the std::list members are used internally by the library code
// and don't need to be used from the outside, and ignoring the warning
// seems to have no adverse effects, so that seems like a good enough
// solution for now.
//
#pragma warning(disable:4251)
#define SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
#define SIGC_NEW_DELETE_IN_LIBRARY_ONLY // To keep ABI compatibility
#define SIGC_HAVE_NAMESPACE_STD 1
#endif /* SIGC_MSC */
//Put things in the std namespace, if they should be there.
#ifndef SIGC_HAVE_NAMESPACE_STD
# define SIGC_USING_STD(Symbol) namespace std { using ::Symbol; }
#else
# define SIGC_USING_STD(Symbol) /* empty */
#endif
#ifdef SIGC_DLL
#if defined(SIGC_BUILD) && defined(_WINDLL)
#define SIGC_API __declspec(dllexport)
#elif !defined(SIGC_BUILD)
#define SIGC_API __declspec(dllimport)
#else
#define SIGC_API
#endif /* SIGC_BUILD - _WINDLL */
#else
#define SIGC_API
#endif /* SIGC_DLL */
#endif /* _SIGCXX_CONFIG_H */