+2007-05-31 Paolo Carlini <pcarlini@suse.de>
+
+ PR libstdc++/31426
+ * include/bits/c++config: Remove namespace association bits
+ from tr1 to std.
+
+ * include/ext/type_traits.h (__promote, __promote2,
+ __promote3, __promote4): Add.
+
+ * include/bits/hashtable.h: New.
+ * include/bits/functional_hash.h: Likewise.
+ * include/tr1/hashtable.h: Likewise.
+
+ * include/tr1_impl/random: New.
+ * include/tr1_impl/cinttypes: Likewise.
+ * include/tr1_impl/cstdlib: Likewise.
+ * include/tr1_impl/unordered_map: Likewise.
+ * include/tr1_impl/cstdio: Likewise.
+ * include/tr1_impl/boost_shared_ptr.h: Likewise.
+ * include/tr1_impl/cctype: Likewise.
+ * include/tr1_impl/random.tcc: Likewise.
+ * include/tr1_impl/tuple: Likewise.
+ * include/tr1_impl/functional_hash.h: Likewise.
+ * include/tr1_impl/hashtable: Likewise.
+ * include/tr1_impl/cmath: Likewise.
+ * include/tr1_impl/type_traitsfwd.h: Likewise.
+ * include/tr1_impl/hashtable_policy.h: Likewise.
+ * include/tr1_impl/cfenv: Likewise.
+ * include/tr1_impl/unordered_set: Likewise.
+ * include/tr1_impl/functional: Likewise.
+ * include/tr1_impl/utility: Likewise.
+ * include/tr1_impl/complex: Likewise.
+ * include/tr1_impl/type_traits: Likewise.
+ * include/tr1_impl/cwchar: Likewise.
+ * include/tr1_impl/cstdint: Likewise.
+ * include/tr1_impl/regex: Likewise.
+ * include/tr1_impl/array: Likewise.
+ * include/tr1_impl/cwctype: Likewise.
+
+ * include/tr1/type_traitsfwd.h: Remove.
+ * include/tr1/boost_shared_ptr.h: Likewise.
+ * include/tr1/common.h: Likewise.
+ * include/tr1/hashtable: Likewise.
+ * include/tr1/hashtable_policy.h: Likewise.
+ * include/tr1/random.tcc: Likewise.
+
+ * include/c_global/cinttypes: Include tr1_impl/cinttypes.
+ * include/c_global/cstdlib: Likewise for cstdlib.
+ * include/c_global/cstdio: Likewise for cstdio.
+ * include/c_global/cctype: Likewise for cctype.
+ * include/c_global/cmath: Likewise for cmath.
+ * include/c_global/cfenv: Likewise for cfenv.
+ * include/c_global/cwchar: Likewise for cwchar.
+ * include/c_global/cstdint: Likewise for cstdint.
+ * include/c_global/cwctype: Likewise for cwctype.
+ * include/tr1/cinttypes: Likewise for cinttypes.
+ * include/tr1/cstdlib: Likewise for cstdlib.
+ * include/tr1/cstdio: Likewise for cstdio.
+ * include/tr1/cctype: Likewise for cctype.
+ * include/tr1/cmath: Likewise for cmath.
+ * include/tr1/cfenv: Likewise for cfenv.
+ * include/tr1/cwchar: Likewise for cwchar.
+ * include/tr1/cstdint: Likewise for cstdint.
+ * include/tr1/cwctype: Likewise for cwctype.
+ * include/tr1/functional_hash.h: Likewise for functional_hash.
+
+ * include/std/tuple: Include tr1_impl/tuple.
+ * include/std/utility: Likewise for utility.
+ * include/std/type_traits: Likewise for type_traits.
+ (is_pod): Just forward to __is_pod.
+ (has_trivial_default_constructor): Just forward to
+ __has_trivial_constructor.
+ (has_trivial_copy_constructor): Just forward to __has_trivial_copy.
+ (has_trivial_assign): Just forward to __has_trivial_assign.
+ (has_trivial_destructor): Just forward to __has_trivial_destructor.
+ (has_nothrow_default_constructor): Just forward to
+ __has_nothrow_constructor.
+ (has_nothrow_copy_constructor): Just forward to __has_nothrow_copy.
+ (has_nothrow_assign): Just forward to __has_nothrow_assign.
+ (is_base_of): Just forward to __is_base_of.
+ (is_signed, is_unsigned): Implement according to the C++0x
+ specifications.
+ * include/std/memory: Likewise for memory.
+ * include/std/regex: Likewise for regex.
+ * include/std/random: Likewise for random.
+ * include/std/unordered_map: Likewise for unordered_map.
+ * include/std/unordered_set: Likewise for unordered_set.
+ * include/std/functional: Likewise for functional.
+ * include/std/complex: Likewise for complex.
+ * include/std/array: Likewise for array.
+ * include/tr1/tuple: Likewise for tuple.
+ * include/tr1/utility: Likewise for utility.
+ * include/tr1/type_traits: Likewise for type_traits
+ * include/tr1/memory: Likewise for memory.
+ * include/tr1/regex: Likewise for regex.
+ * include/tr1/random: Likewise for random.
+ * include/tr1/unordered_map: Likewise for unordered_map.
+ * include/tr1/unordered_set: Likewise for unordered_set.
+ * include/tr1/functional: Likewise for functional.
+ * include/tr1/complex: Likewise for complex.
+ * include/tr1/array: Likewise for array.
+
+ * include/c_global/ctgmath: Tweak.
+ * include/c_global/cstdarg: Likewise.
+ * include/c_global/ctime: Likewise.
+ * include/c_global/climits: Likewise.
+ * include/c_global/cfloat: Likewise.
+ * include/c_global/ccomplex: Likewise.
+ * include/c_global/cstdbool: Likewise.
+
+ * include/tr1/poly_laguerre.tcc: Tweak, don't use _GLIBCXX_TR1.
+ * include/tr1/riemann_zeta.tcc: Likewise.
+ * include/tr1/beta_function.tcc: Likewise.
+ * include/tr1/exp_integral.tcc: Likewise.
+ * include/tr1/hypergeometric.tcc: Likewise.
+ * include/tr1/modified_bessel_func.tcc: Likewise.
+ * include/tr1/legendre_function.tcc: Likewise.
+ * include/tr1/special_function_util.h: Likewise.
+ * include/tr1/bessel_function.tcc: Likewise.
+ * include/tr1/poly_hermite.tcc: Likewise.
+ * include/tr1/ell_integral.tcc: Likewise.
+ * include/tr1/gamma.tcc: Likewise.
+ * include/tr1/stdlib.h: Likewise.
+ * include/tr1/math.h: Likewise.
+
+ * include/tr1/complex.h: Minor tweaks.
+ * include/tr1/wctype.h: Likewise.
+ * include/tr1/wchar.h: Likewise.
+ * include/tr1/inttypes.h: Likewise.
+ * include/tr1/tgmath.h: Likewise.
+ * include/tr1/cstdbool: Likewise.
+ * include/tr1/cfloat: Likewise.
+ * include/tr1/ccomplex: Likewise.
+ * include/tr1/ctime: Likewise.
+ * include/tr1/climits: Likewise.
+ * include/tr1/ctgmath: Likewise.
+ * include/tr1/cstdarg: Likewise.
+
+ * testsuite/tr1/headers.cc: Move...
+ * testsuite/tr1/headers/all.cc: ... here.
+ * testsuite/tr1/using_namespace_std_tr1.cc: Move...
+ * testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc: ... here.
+ * testsuite/tr1/headers/using_namespace_std_tr1.cc ... here.
+ * testsuite/tr1/headers/c++200x/using_namespace_std_tr1.cc: New.
+
+ * testsuite/20_util/tuple/requirements/explicit_instantiation.cc:
+ Adjust namespace.
+ * testsuite/20_util/has_nothrow_copy_constructor/value.cc: Adjust to
+ the C++0x requirements.
+ * testsuite/20_util/has_nothrow_default_constructor/value.cc: Likewise.
+ * testsuite/20_util/has_trivial_copy_constructor/value.cc: Likewise.
+ * testsuite/20_util/has_trivial_default_constructor/value.cc: Likewise.
+
+ * testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust
+ dg-error lines.
+ * testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
+ Likewise.
+ * testsuite/20_util/headers/type_traits/types_std_c++0x_neg.cc:
+ Un-xfail.
+
+ * testsuite/20_util/is_signed/value.cc: New.
+ * testsuite/20_util/is_signed/requirements/typedefs.cc: Likewise.
+ * testsuite/20_util/is_signed/requirements/explicit_instantiation.cc:
+ Likewise.
+ * testsuite/20_util/is_unsigned/value.cc: Likewise..
+ * testsuite/20_util/is_unsigned/requirements/typedefs.cc: Likewise.
+ * testsuite/20_util/is_unsigned/requirements/explicit_instantiation.cc:
+ Likewise.
+
+ * include/Makefile.am: Adjust.
+ * include/Makefile.in: Regenerate.
+
2007-05-31 Paolo Carlini <pcarlini@suse.de>
PR c++/32158 (libstdc++ bits)
${bits_srcdir}/deque.tcc \
${bits_srcdir}/fstream.tcc \
${bits_srcdir}/functexcept.h \
+ ${bits_srcdir}/functional_hash.h \
${bits_srcdir}/gslice.h \
${bits_srcdir}/gslice_array.h \
+ ${bits_srcdir}/hashtable.h \
${bits_srcdir}/indirect_array.h \
${bits_srcdir}/ios_base.h \
${bits_srcdir}/istream.tcc \
${tr1_srcdir}/array \
${tr1_srcdir}/bessel_function.tcc \
${tr1_srcdir}/beta_function.tcc \
- ${tr1_srcdir}/boost_shared_ptr.h \
${tr1_srcdir}/ccomplex \
${tr1_srcdir}/cctype \
${tr1_srcdir}/cfenv \
${tr1_srcdir}/cinttypes \
${tr1_srcdir}/climits \
${tr1_srcdir}/cmath \
- ${tr1_srcdir}/common.h \
${tr1_srcdir}/complex \
${tr1_srcdir}/complex.h \
${tr1_srcdir}/cstdarg \
${tr1_srcdir}/functional \
${tr1_srcdir}/functional_hash.h \
${tr1_srcdir}/gamma.tcc \
- ${tr1_srcdir}/hashtable \
${tr1_srcdir}/hypergeometric.tcc \
- ${tr1_srcdir}/hashtable_policy.h \
+ ${tr1_srcdir}/hashtable.h \
${tr1_srcdir}/inttypes.h \
${tr1_srcdir}/limits.h \
${tr1_srcdir}/math.h \
${tr1_srcdir}/poly_laguerre.tcc \
${tr1_srcdir}/legendre_function.tcc \
${tr1_srcdir}/random \
- ${tr1_srcdir}/random.tcc \
${tr1_srcdir}/regex \
${tr1_srcdir}/riemann_zeta.tcc \
${tr1_srcdir}/special_function_util.h \
${tr1_srcdir}/tgmath.h \
${tr1_srcdir}/tuple \
${tr1_srcdir}/type_traits \
- ${tr1_srcdir}/type_traitsfwd.h \
${tr1_srcdir}/unordered_set \
${tr1_srcdir}/unordered_map \
${tr1_srcdir}/utility \
${tr1_srcdir}/wctype.h
+tr1_impl_srcdir = ${glibcxx_srcdir}/include/tr1_impl
+tr1_impl_builddir = ./tr1_impl
+tr1_impl_headers = \
+ ${tr1_impl_srcdir}/array \
+ ${tr1_impl_srcdir}/boost_shared_ptr.h \
+ ${tr1_impl_srcdir}/cctype \
+ ${tr1_impl_srcdir}/cfenv \
+ ${tr1_impl_srcdir}/cinttypes \
+ ${tr1_impl_srcdir}/cmath \
+ ${tr1_impl_srcdir}/complex \
+ ${tr1_impl_srcdir}/cstdint \
+ ${tr1_impl_srcdir}/cstdio \
+ ${tr1_impl_srcdir}/cstdlib \
+ ${tr1_impl_srcdir}/cwchar \
+ ${tr1_impl_srcdir}/cwctype \
+ ${tr1_impl_srcdir}/functional \
+ ${tr1_impl_srcdir}/functional_hash.h \
+ ${tr1_impl_srcdir}/hashtable \
+ ${tr1_impl_srcdir}/hashtable_policy.h \
+ ${tr1_impl_srcdir}/random \
+ ${tr1_impl_srcdir}/random.tcc \
+ ${tr1_impl_srcdir}/regex \
+ ${tr1_impl_srcdir}/tuple \
+ ${tr1_impl_srcdir}/type_traits \
+ ${tr1_impl_srcdir}/type_traitsfwd.h \
+ ${tr1_impl_srcdir}/unordered_map \
+ ${tr1_impl_srcdir}/unordered_set \
+ ${tr1_impl_srcdir}/utility
+
+
# This is the common subset of C++ files that all three "C" header models use.
c_base_srcdir = $(C_INCLUDE_DIR)
c_base_builddir = .
allstamped = \
stamp-std stamp-bits stamp-c_base stamp-c_base_extra \
stamp-c_compatibility stamp-backward stamp-ext stamp-pb \
- stamp-tr1 stamp-debug stamp-host
+ stamp-tr1 stamp-tr1-impl stamp-debug stamp-host
# List of all files that are created by explicit building, editing, or
# catenation.
fi ;\
$(STAMP) stamp-tr1
+stamp-tr1-impl: ${tr1_impl_headers}
+ @if [ ! -d "${tr1_impl_builddir}" ]; then \
+ mkdir -p ${tr1_impl_builddir} ;\
+ fi ;\
+ if [ ! -f stamp-tr1-impl ]; then \
+ (cd ${tr1_impl_builddir} && $(LN_S) $? . || true) ;\
+ fi ;\
+ $(STAMP) stamp-tr1-impl
+
stamp-debug: ${debug_headers}
@if [ ! -d "${debug_builddir}" ]; then \
mkdir -p ${debug_builddir} ;\
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_builddir}
for file in ${tr1_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_builddir}; done
+ $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}
+ for file in ${tr1_impl_headers}; do \
+ $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}; done
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
for file in ${c_base_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
# developer tries to create them via make in the include build
# directory. (This is more of an example of how this kind of rule can
# be made.)
-.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(ext_headers)
+.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr1_impl_headers)
+ $(ext_headers)
$(std_headers): ; @:
$(c_base_headers): ; @:
$(tr1_headers): ; @:
+$(tr1_impl_headers): ; @:
$(ext_headers): ; @:
${bits_srcdir}/deque.tcc \
${bits_srcdir}/fstream.tcc \
${bits_srcdir}/functexcept.h \
+ ${bits_srcdir}/functional_hash.h \
${bits_srcdir}/gslice.h \
${bits_srcdir}/gslice_array.h \
+ ${bits_srcdir}/hashtable.h \
${bits_srcdir}/indirect_array.h \
${bits_srcdir}/ios_base.h \
${bits_srcdir}/istream.tcc \
${tr1_srcdir}/array \
${tr1_srcdir}/bessel_function.tcc \
${tr1_srcdir}/beta_function.tcc \
- ${tr1_srcdir}/boost_shared_ptr.h \
${tr1_srcdir}/ccomplex \
${tr1_srcdir}/cctype \
${tr1_srcdir}/cfenv \
${tr1_srcdir}/cinttypes \
${tr1_srcdir}/climits \
${tr1_srcdir}/cmath \
- ${tr1_srcdir}/common.h \
${tr1_srcdir}/complex \
${tr1_srcdir}/complex.h \
${tr1_srcdir}/cstdarg \
${tr1_srcdir}/functional \
${tr1_srcdir}/functional_hash.h \
${tr1_srcdir}/gamma.tcc \
- ${tr1_srcdir}/hashtable \
${tr1_srcdir}/hypergeometric.tcc \
- ${tr1_srcdir}/hashtable_policy.h \
+ ${tr1_srcdir}/hashtable.h \
${tr1_srcdir}/inttypes.h \
${tr1_srcdir}/limits.h \
${tr1_srcdir}/math.h \
${tr1_srcdir}/poly_laguerre.tcc \
${tr1_srcdir}/legendre_function.tcc \
${tr1_srcdir}/random \
- ${tr1_srcdir}/random.tcc \
${tr1_srcdir}/regex \
${tr1_srcdir}/riemann_zeta.tcc \
${tr1_srcdir}/special_function_util.h \
${tr1_srcdir}/tgmath.h \
${tr1_srcdir}/tuple \
${tr1_srcdir}/type_traits \
- ${tr1_srcdir}/type_traitsfwd.h \
${tr1_srcdir}/unordered_set \
${tr1_srcdir}/unordered_map \
${tr1_srcdir}/utility \
${tr1_srcdir}/wchar.h \
${tr1_srcdir}/wctype.h
+tr1_impl_srcdir = ${glibcxx_srcdir}/include/tr1_impl
+tr1_impl_builddir = ./tr1_impl
+tr1_impl_headers = \
+ ${tr1_impl_srcdir}/array \
+ ${tr1_impl_srcdir}/boost_shared_ptr.h \
+ ${tr1_impl_srcdir}/cctype \
+ ${tr1_impl_srcdir}/cfenv \
+ ${tr1_impl_srcdir}/cinttypes \
+ ${tr1_impl_srcdir}/cmath \
+ ${tr1_impl_srcdir}/complex \
+ ${tr1_impl_srcdir}/cstdint \
+ ${tr1_impl_srcdir}/cstdio \
+ ${tr1_impl_srcdir}/cstdlib \
+ ${tr1_impl_srcdir}/cwchar \
+ ${tr1_impl_srcdir}/cwctype \
+ ${tr1_impl_srcdir}/functional \
+ ${tr1_impl_srcdir}/functional_hash.h \
+ ${tr1_impl_srcdir}/hashtable \
+ ${tr1_impl_srcdir}/hashtable_policy.h \
+ ${tr1_impl_srcdir}/random \
+ ${tr1_impl_srcdir}/random.tcc \
+ ${tr1_impl_srcdir}/regex \
+ ${tr1_impl_srcdir}/tuple \
+ ${tr1_impl_srcdir}/type_traits \
+ ${tr1_impl_srcdir}/type_traitsfwd.h \
+ ${tr1_impl_srcdir}/unordered_map \
+ ${tr1_impl_srcdir}/unordered_set \
+ ${tr1_impl_srcdir}/utility
+
# This is the common subset of C++ files that all three "C" header models use.
c_base_srcdir = $(C_INCLUDE_DIR)
allstamped = \
stamp-std stamp-bits stamp-c_base stamp-c_base_extra \
stamp-c_compatibility stamp-backward stamp-ext stamp-pb \
- stamp-tr1 stamp-debug stamp-host
+ stamp-tr1 stamp-tr1-impl stamp-debug stamp-host
# List of all files that are created by explicit building, editing, or
fi ;\
$(STAMP) stamp-tr1
+stamp-tr1-impl: ${tr1_impl_headers}
+ @if [ ! -d "${tr1_impl_builddir}" ]; then \
+ mkdir -p ${tr1_impl_builddir} ;\
+ fi ;\
+ if [ ! -f stamp-tr1-impl ]; then \
+ (cd ${tr1_impl_builddir} && $(LN_S) $? . || true) ;\
+ fi ;\
+ $(STAMP) stamp-tr1-impl
+
stamp-debug: ${debug_headers}
@if [ ! -d "${debug_builddir}" ]; then \
mkdir -p ${debug_builddir} ;\
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_builddir}
for file in ${tr1_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_builddir}; done
+ $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}
+ for file in ${tr1_impl_headers}; do \
+ $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_impl_builddir}; done
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
for file in ${c_base_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
# developer tries to create them via make in the include build
# directory. (This is more of an example of how this kind of rule can
# be made.)
-.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(ext_headers)
+.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr1_impl_headers)
+ $(ext_headers)
$(std_headers): ; @:
$(c_base_headers): ; @:
$(tr1_headers): ; @:
+$(tr1_impl_headers): ; @:
$(ext_headers): ; @:
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
# define _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG 1
#endif
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# define _GLIBCXX_NAMESPACE_ASSOCIATION_CXX0X 1
-#endif
-
#define _GLIBCXX_NAMESPACE_ASSOCIATION_VERSION
// Macros for namespace scope.
#endif
#endif
-// Namespace associations for C++0x, TR1 in std.
-#if _GLIBCXX_NAMESPACE_ASSOCIATION_CXX0X
-namespace std
-{
- namespace __cxx200x { }
- using namespace __cxx200x __attribute__ ((strong));
-}
-# define _GLIBCXX_TR1 __cxx200x
-#else
-# define _GLIBCXX_TR1 tr1
-#endif
-
// Define if compatibility should be provided for -mlong-double-64.
#undef _GLIBCXX_LONG_DOUBLE_COMPAT
--- /dev/null
+// functional_hash.h header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02110-1301, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file functional_hash.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _FUNCTIONAL_HASH_H
+#define _FUNCTIONAL_HASH_H 1
+
+#pragma GCC system_header
+
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+# include <c++0x_warning.h>
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/functional_hash.h>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/functional_hash.h>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif // _FUNCTIONAL_HASH_H
+
--- /dev/null
+// hashtable.h header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02110-1301, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file hashtable.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _HASHTABLE_H
+#define _HASHTABLE_H 1
+
+#pragma GCC system_header
+
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+# include <c++0x_warning.h>
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/hashtable>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/hashtable>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif // _HASHTABLE_H
+
#ifndef _GLIBCXX_CCOMPLEX
#define _GLIBCXX_CCOMPLEX 1
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/ccomplex>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <complex>
+#endif
// -*- C++ -*- forwarding header.
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
_GLIBCXX_END_NAMESPACE
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cctype>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cctype>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cctype>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif
#ifndef _GLIBCXX_CFENV
#define _GLIBCXX_CFENV 1
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cfenv>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <bits/c++config.h>
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cfenv>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cfenv>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif
#define _GLIBCXX_CFLOAT 1
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cfloat>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# ifndef DECIMAL_DIG
+# define DECIMAL_DIG __DECIMAL_DIG__
+# endif
+# ifndef FLT_EVAL_METHOD
+# define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+# endif
#endif
#endif
#ifndef _GLIBCXX_CINTTYPES
#define _GLIBCXX_CINTTYPES 1
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cinttypes>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cstdint>
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cinttypes>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cinttypes>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif
// -*- C++ -*- forwarding header.
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#ifndef _GLIBCXX_CLIMITS
#define _GLIBCXX_CLIMITS 1
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/climits>
+#ifndef LLONG_MIN
+#define LLONG_MIN -__LONG_LONG_MAX__ - 1
+#endif
+
+#ifndef LLONG_MAX
+#define LLONG_MAX __LONG_LONG_MAX__
+#endif
+
+#ifndef ULLONG_MAX
+#define ULLONG_MAX __LONG_LONG_MAX__ * 2ULL + 1
#endif
#endif
// -*- C++ -*- C forwarding header.
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// Forward declaration of a helper function. This really should be
// an `exported' forward declaration.
- template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
+ template<typename _Tp>
+ _Tp __cmath_power(_Tp, unsigned int);
+
+ template<typename _Tp>
+ inline _Tp
+ __pow_helper(_Tp __x, int __n)
+ {
+ return __n < 0
+ ? _Tp(1)/__cmath_power(__x, -__n)
+ : __cmath_power(__x, __n);
+ }
inline double
abs(double __x)
{ return __builtin_asinl(__x); }
template<typename _Tp>
- inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
- double>::__type
+ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
asin(_Tp __x)
{ return __builtin_asin(__x); }
{ return __builtin_atanl(__x); }
template<typename _Tp>
- inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
- double>::__type
+ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
atan(_Tp __x)
{ return __builtin_atan(__x); }
{ return __builtin_atan2l(__y, __x); }
template<typename _Tp, typename _Up>
- inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
- && __is_integer<_Up>::__value,
- double>::__type
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
atan2(_Tp __y, _Up __x)
- { return __builtin_atan2(__y, __x); }
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return atan2(__type(__y), __type(__x));
+ }
using ::ceil;
modf(long double __x, long double* __iptr)
{ return __builtin_modfl(__x, __iptr); }
- template<typename _Tp>
- inline _Tp
- __pow_helper(_Tp __x, int __n)
- {
- return __n < 0
- ? _Tp(1)/__cmath_power(__x, -__n)
- : __cmath_power(__x, __n);
- }
-
using ::pow;
inline float
pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
+ // DR 550.
inline double
pow(double __x, int __i)
{ return __builtin_powi(__x, __i); }
pow(long double __x, int __n)
{ return __builtin_powil(__x, __n); }
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ pow(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return pow(__type(__x), __type(__y));
+ }
+
using ::sin;
inline float
#endif
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cmath>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# include <type_traits>
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cmath>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cmath>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif
_GLIBCXX_END_NAMESPACE
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdarg>
-#endif
-
#endif
#ifndef _GLIBCXX_CSTDBOOL
#define _GLIBCXX_CSTDBOOL 1
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdbool>
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+# include <c++0x_warning.h>
#else
-# include <c++0x_warning.h>
+# include <bits/c++config.h>
+# if _GLIBCXX_HAVE_STDBOOL_H
+# include_next <stdbool.h>
+# endif
#endif
#endif
#ifndef _GLIBCXX_CSTDINT
#define _GLIBCXX_CSTDINT 1
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdint>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <bits/c++config.h>
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cstdint>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cstdint>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+#endif
// -*- C++ -*- forwarding header.
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#endif // _GLIBCXX_USE_C99
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdio>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cstdio>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cstdio>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif
// -*- C++ -*- forwarding header.
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#endif // _GLIBCXX_USE_C99
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cstdlib>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cstdlib>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cstdlib>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif // !_GLIBCXX_HOSTED
#ifndef _GLIBCXX_CTGMATH
#define _GLIBCXX_CTGMATH 1
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/ctgmath>
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+# include <c++0x_warning.h>
#else
-# include <c++0x_warning.h>
+# include <cmath>
#endif
#endif
// -*- C++ -*- forwarding header.
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
_GLIBCXX_END_NAMESPACE
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/ctime>
-#endif
-
#endif
#endif //_GLIBCXX_USE_WCHAR_T
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cwchar>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cwchar>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cwchar>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif
// -*- C++ -*- forwarding header.
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#endif //_GLIBCXX_USE_WCHAR_T
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/cwctype>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/cwctype>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/cwctype>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif
__is_null_pointer(_Type)
{ return false; }
+
+ // For complex and cmath
+ template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+ struct __promote
+ { typedef double __type; };
+
+ template<typename _Tp>
+ struct __promote<_Tp, false>
+ { typedef _Tp __type; };
+
+ template<typename _Tp, typename _Up>
+ struct __promote_2
+ {
+ private:
+ typedef typename __promote<_Tp>::__type __type1;
+ typedef typename __promote<_Up>::__type __type2;
+
+ public:
+ typedef __typeof__(__type1() + __type2()) __type;
+ };
+
+ template<typename _Tp, typename _Up, typename _Vp>
+ struct __promote_3
+ {
+ private:
+ typedef typename __promote<_Tp>::__type __type1;
+ typedef typename __promote<_Up>::__type __type2;
+ typedef typename __promote<_Vp>::__type __type3;
+
+ public:
+ typedef __typeof__(__type1() + __type2() + __type3()) __type;
+ };
+
+ template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
+ struct __promote_4
+ {
+ private:
+ typedef typename __promote<_Tp>::__type __type1;
+ typedef typename __promote<_Up>::__type __type2;
+ typedef typename __promote<_Vp>::__type __type3;
+ typedef typename __promote<_Wp>::__type __type4;
+
+ public:
+ typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
+ };
+
_GLIBCXX_END_NAMESPACE
#endif
* This is a Standard C++ Library header.
*/
-#ifndef _GLIBCXX_ARRAY
-#define _GLIBCXX_ARRAY 1
+#ifndef _GLIBCXX_CXX0X_ARRAY
+#define _GLIBCXX_CXX0X_ARRAY 1
#pragma GCC system_header
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/array>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <bits/stl_algobase.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/array>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/array>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+#endif // _GLIBCXX_CXX0X_ARRAY
#include <bits/c++config.h>
#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
#include <cmath>
#include <sstream>
_GLIBCXX_END_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+
+ // See ext/type_traits.h for the primary template.
+ template<typename _Tp, typename _Up>
+ struct __promote_2<std::complex<_Tp>, _Up>
+ {
+ public:
+ typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+ };
+
+ template<typename _Tp, typename _Up>
+ struct __promote_2<_Tp, std::complex<_Up> >
+ {
+ public:
+ typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+ };
+
+ template<typename _Tp, typename _Up>
+ struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
+ {
+ public:
+ typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+ };
+
+_GLIBCXX_END_NAMESPACE
+
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/complex>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# include <type_traits>
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/complex>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/complex>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif /* _GLIBCXX_COMPLEX */
#include <bits/stl_function.h>
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/functional>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# include <cmath>
+# include <string>
+# include <typeinfo>
+# include <ext/type_traits.h>
+# include <tuple>
+# include <type_traits>
+# include <bits/functional_hash.h>
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/functional>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/functional>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
-#endif /* _GLIBCXX_FUNCTIONAL */
+#endif // _GLIBCXX_FUNCTIONAL
#include <bits/stl_raw_storage_iter.h>
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/memory>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# include <exception> // std::exception
+# include <new> // std::bad_alloc
+# include <typeinfo> // std::type_info in get_deleter
+# include <bits/stl_algobase.h> // std::swap
+# include <iosfwd> // std::basic_ostream
+# include <ext/atomicity.h>
+# include <ext/concurrence.h>
+# include <bits/functexcept.h>
+# include <bits/stl_function.h> // std::less
+# include <debug/debug.h>
+# include <type_traits>
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/boost_shared_ptr.h>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/boost_shared_ptr.h>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif /* _GLIBCXX_MEMORY */
#pragma GCC system_header
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/random>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <iosfwd>
+#include <limits>
+#include <ext/type_traits.h>
+#include <ext/numeric_traits.h>
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+#include <type_traits>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/random>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/random>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+#endif // _GLIBCXX_RANDOM
* This is a Standard C++ Library header.
*/
-#ifndef _GLIBCXX_REGEX
-#define _GLIBCXX_REGEX 1
+#ifndef _GLIBCXX_CXX0X_REGEX
+#define _GLIBCXX_CXX0X_REGEX 1
#pragma GCC system_header
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/regex>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <algorithm>
+#include <bitset>
+#include <iterator>
+#include <locale>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <utility>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/regex>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/regex>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+#endif // _GLIBCXX_CXX0X_REGEX
* This is a Standard C++ Library header.
*/
-#ifndef _GLIBCXX_TUPLE
-#define _GLIBCXX_TUPLE 1
+#ifndef _GLIBCXX_CXX0X_TUPLE
+#define _GLIBCXX_CXX0X_TUPLE 1
#pragma GCC system_header
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/tuple>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <utility>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/tuple>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/tuple>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+#endif // _GLIBCXX_CXX0X_TUPLE
* This is a Standard C++ Library header.
*/
-#ifndef _GLIBCXX_TYPE_TRAITS
-#define _GLIBCXX_TYPE_TRAITS 1
+#ifndef _GLIBCXX_CXX0X_TYPE_TRAITS
+#define _GLIBCXX_CXX0X_TYPE_TRAITS 1
#pragma GCC system_header
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/type_traits>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cstddef>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/type_traits>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/type_traits>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+
+namespace std
+{
+ template<typename _Tp,
+ bool = is_integral<_Tp>::value,
+ bool = is_floating_point<_Tp>::value>
+ struct __is_signed_helper
+ : public false_type { };
+
+ template<typename _Tp>
+ struct __is_signed_helper<_Tp, false, true>
+ : public true_type { };
+
+ template<typename _Tp>
+ struct __is_signed_helper<_Tp, true, false>
+ : public integral_constant<bool, _Tp(-1) < _Tp(0)>
+ { };
+
+ template<typename _Tp>
+ struct is_signed
+ : public integral_constant<bool, __is_signed_helper<_Tp>::value>
+ { };
+
+ template<typename _Tp>
+ struct is_unsigned
+ : public integral_constant<bool, (is_arithmetic<_Tp>::value
+ && !is_signed<_Tp>::value)>
+ { };
+
+ template<typename _Tp>
+ struct is_pod
+ : public integral_constant<bool, __is_pod(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_trivial_default_constructor
+ : public integral_constant<bool, __has_trivial_constructor(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_trivial_copy_constructor
+ : public integral_constant<bool, __has_trivial_copy(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_trivial_assign
+ : public integral_constant<bool, __has_trivial_assign(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_trivial_destructor
+ : public integral_constant<bool, __has_trivial_destructor(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_nothrow_default_constructor
+ : public integral_constant<bool, __has_nothrow_constructor(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_nothrow_copy_constructor
+ : public integral_constant<bool, __has_nothrow_copy(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_nothrow_assign
+ : public integral_constant<bool, __has_nothrow_assign(_Tp)>
+ { };
+
+ template<typename _Base, typename _Derived>
+ struct is_base_of
+ : public integral_constant<bool, __is_base_of(_Base, _Derived)>
+ { };
+
+ // XXX FIXME
+ // The C++0x specifications are different, see N2255.
+ template<typename _From, typename _To>
+ struct __is_convertible_simple
+ : public __sfinae_types
+ {
+ private:
+ static __one __test(_To);
+ static __two __test(...);
+ static _From __makeFrom();
+
+ public:
+ static const bool __value = sizeof(__test(__makeFrom())) == 1;
+ };
+
+ template<typename _Tp>
+ struct __is_int_or_cref
+ {
+ typedef typename remove_reference<_Tp>::type __rr_Tp;
+ static const bool __value = (is_integral<_Tp>::value
+ || (is_integral<__rr_Tp>::value
+ && is_const<__rr_Tp>::value
+ && !is_volatile<__rr_Tp>::value));
+ };
+
+ template<typename _From, typename _To,
+ bool = (is_void<_From>::value || is_void<_To>::value
+ || is_function<_To>::value || is_array<_To>::value
+ // This special case is here only to avoid warnings.
+ || (is_floating_point<typename
+ remove_reference<_From>::type>::value
+ && __is_int_or_cref<_To>::__value))>
+ struct __is_convertible_helper
+ {
+ // "An imaginary lvalue of type From...".
+ static const bool __value = (__is_convertible_simple<typename
+ add_reference<_From>::type, _To>::__value);
+ };
+
+ template<typename _From, typename _To>
+ struct __is_convertible_helper<_From, _To, true>
+ { static const bool __value = (is_void<_To>::value
+ || (__is_int_or_cref<_To>::__value
+ && !is_void<_From>::value)); };
+
+ template<typename _From, typename _To>
+ struct is_convertible
+ : public integral_constant<bool,
+ __is_convertible_helper<_From, _To>::__value>
+ { };
+
// Define a nested type if some predicate holds.
template<bool, typename _Tp = void>
// Utility for finding the unsigned versions of signed integral types.
template<typename _Tp>
- struct __make_unsigned;
+ struct __make_unsigned
+ { typedef _Tp __type; };
template<>
struct __make_unsigned<char>
// Select between integral and enum: not possible to be both.
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
- bool _IsUnsigned = is_unsigned<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
struct __make_unsigned_selector;
template<typename _Tp>
- struct __make_unsigned_selector<_Tp, true, true, false>
- { typedef _Tp __type; };
-
- template<typename _Tp>
- struct __make_unsigned_selector<_Tp, true, false, false>
+ struct __make_unsigned_selector<_Tp, true, false>
{
private:
typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
};
template<typename _Tp>
- struct __make_unsigned_selector<_Tp, false, false, true>
+ struct __make_unsigned_selector<_Tp, false, true>
{
private:
// GNU enums start with sizeof short.
// Utility for finding the signed versions of unsigned integral types.
template<typename _Tp>
- struct __make_signed;
+ struct __make_signed
+ { typedef _Tp __type; };
template<>
struct __make_signed<char>
// Select between integral and enum: not possible to be both.
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
- bool _IsSigned = is_signed<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
struct __make_signed_selector;
template<typename _Tp>
- struct __make_signed_selector<_Tp, true, true, false>
- { typedef _Tp __type; };
-
- template<typename _Tp>
- struct __make_signed_selector<_Tp, true, false, false>
+ struct __make_signed_selector<_Tp, true, false>
{
private:
typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
};
template<typename _Tp>
- struct __make_signed_selector<_Tp, false, false, true>
+ struct __make_signed_selector<_Tp, false, true>
{
private:
// GNU enums start with sizeof short.
// Integral, but don't define.
template<>
struct make_signed<bool>;
+}
-
- template<typename _Tp>
- struct has_nothrow_default_constructor
- : public integral_constant<bool, is_pod<_Tp>::value> { };
-
- template<typename _Tp>
- struct has_nothrow_copy_constructor
- : public integral_constant<bool, is_pod<_Tp>::value> { };
-
- template<typename _Tp>
- struct has_trivial_default_constructor
- : public integral_constant<bool, is_pod<_Tp>::value> { };
-
- template<typename _Tp>
- struct has_trivial_copy_constructor
- : public integral_constant<bool, is_pod<_Tp>::value> { };
-
-_GLIBCXX_END_NAMESPACE
-
-#endif
+#endif // _GLIBCXX_CXX0X_TYPE_TRAITS
#pragma GCC system_header
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/unordered_map>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <type_traits>
+#include <bits/functional_hash.h>
+#include <bits/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/unordered_map>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/unordered_map>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+#endif // _GLIBCXX_UNORDERED_MAP
#pragma GCC system_header
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/unordered_set>
-#else
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
-#endif
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <type_traits>
+#include <bits/functional_hash.h>
+#include <bits/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/unordered_set>
+#else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/unordered_set>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+#endif
+#endif // _GLIBCXX_UNORDERED_SET
#include <bits/stl_pair.h>
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# include <tr1/utility>
+# if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# error C++0x header cannot be included from TR1 header
+# endif
+# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# include <tr1_impl/utility>
+# else
+# define _GLIBCXX_INCLUDE_AS_CXX0X
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1
+# define _GLIBCXX_END_NAMESPACE_TR1
+# define _GLIBCXX_TR1
+# include <tr1_impl/utility>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_CXX0X
+# endif
#endif
#endif /* _GLIBCXX_UTILITY */
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_ARRAY
-#define _TR1_ARRAY 1
+#ifndef _GLIBCXX_TR1_ARRAY
+#define _GLIBCXX_TR1_ARRAY 1
-#include <bits/stl_algobase.h>
-
-//namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- /// @brief struct array [6.2.2].
- /// NB: Requires complete type _Tp.
- template<typename _Tp, std::size_t _Nm>
- struct array
- {
- typedef _Tp value_type;
- typedef value_type& reference;
- typedef const value_type& const_reference;
- typedef value_type* iterator;
- typedef const value_type* const_iterator;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
- // Support for zero-sized arrays mandatory.
- value_type _M_instance[_Nm ? _Nm : 1] __attribute__((__aligned__));
-
- // No explicit construct/copy/destroy for aggregate type.
-
- void
- assign(const value_type& __u)
- { std::fill_n(begin(), size(), __u); }
-
- void
- swap(array& __other)
- { std::swap_ranges(begin(), end(), __other.begin()); }
-
- // Iterators.
- iterator
- begin()
- { return iterator(&_M_instance[0]); }
-
- const_iterator
- begin() const
- { return const_iterator(&_M_instance[0]); }
-
- iterator
- end()
- { return iterator(&_M_instance[_Nm]); }
-
- const_iterator
- end() const
- { return const_iterator(&_M_instance[_Nm]); }
-
- reverse_iterator
- rbegin()
- { return reverse_iterator(end()); }
-
- const_reverse_iterator
- rbegin() const
- { return const_reverse_iterator(end()); }
-
- reverse_iterator
- rend()
- { return reverse_iterator(begin()); }
-
- const_reverse_iterator
- rend() const
- { return const_reverse_iterator(begin()); }
-
- // Capacity.
- size_type
- size() const { return _Nm; }
-
- size_type
- max_size() const { return _Nm; }
-
- bool
- empty() const { return size() == 0; }
-
- // Element access.
- reference
- operator[](size_type __n)
- { return _M_instance[__n]; }
-
- const_reference
- operator[](size_type __n) const
- { return _M_instance[__n]; }
-
- reference
- at(size_type __n)
- {
- _M_check<_Nm>(__n);
- return _M_instance[__n];
- }
-
- const_reference
- at(size_type __n) const
- {
- _M_check<_Nm>(__n);
- return _M_instance[__n];
- }
-
- reference
- front()
- { return *begin(); }
+#pragma GCC system_header
- const_reference
- front() const
- { return *begin(); }
-
- reference
- back()
- { return _Nm ? *(end() - 1) : *end(); }
-
- const_reference
- back() const
- { return _Nm ? *(end() - 1) : *end(); }
-
- _Tp*
- data()
- { return &_M_instance[0]; }
-
- const _Tp*
- data() const
- { return &_M_instance[0]; }
-
- private:
- template<std::size_t _Mm>
- typename __gnu_cxx::__enable_if<_Mm, void>::__type
- _M_check(size_type __n) const
- {
- if (__builtin_expect(__n >= _Mm, false))
- std::__throw_out_of_range(__N("array::_M_check"));
- }
-
- // Avoid "unsigned comparison with zero" warnings.
- template<std::size_t _Mm>
- typename __gnu_cxx::__enable_if<!_Mm, void>::__type
- _M_check(size_type) const
- { std::__throw_out_of_range(__N("array::_M_check")); }
- };
-
- // Array comparisons.
- template<typename _Tp, std::size_t _Nm>
- inline bool
- operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
- { return std::equal(__one.begin(), __one.end(), __two.begin()); }
-
- template<typename _Tp, std::size_t _Nm>
- inline bool
- operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
- { return !(__one == __two); }
-
- template<typename _Tp, std::size_t _Nm>
- inline bool
- operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
- {
- return std::lexicographical_compare(__a.begin(), __a.end(),
- __b.begin(), __b.end());
- }
-
- template<typename _Tp, std::size_t _Nm>
- inline bool
- operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
- { return __two < __one; }
-
- template<typename _Tp, std::size_t _Nm>
- inline bool
- operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
- { return !(__one > __two); }
-
- template<typename _Tp, std::size_t _Nm>
- inline bool
- operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
- { return !(__one < __two); }
-
- // Specialized algorithms [6.2.2.2].
- template<typename _Tp, std::size_t _Nm>
- inline void
- swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
- { std::swap_ranges(__one.begin(), __one.end(), __two.begin()); }
-
- // Tuple interface to class template array [6.2.2.5].
- template<typename _Tp> class tuple_size;
- template<int _Int, typename _Tp> class tuple_element;
-
- template<typename _Tp, std::size_t _Nm>
- struct tuple_size<array<_Tp, _Nm> >
- { static const int value = _Nm; };
-
- template<typename _Tp, std::size_t _Nm>
- const int tuple_size<array<_Tp, _Nm> >::value;
-
- template<int _Int, typename _Tp, std::size_t _Nm>
- struct tuple_element<_Int, array<_Tp, _Nm> >
- { typedef _Tp type; };
-
- template<int _Int, typename _Tp, std::size_t _Nm>
- inline _Tp&
- get(array<_Tp, _Nm>& __arr)
- { return __arr[_Int]; }
-
- template<int _Int, typename _Tp, std::size_t _Nm>
- inline const _Tp&
- get(const array<_Tp, _Nm>& __arr)
- { return __arr[_Int]; }
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
-_GLIBCXX_END_NAMESPACE
-}
+#include <bits/stl_algobase.h>
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/array>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/array>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
+
+#endif // _GLIBCXX_TR1_ARRAY
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 240-245
-#ifndef _TR1_BESSEL_FUNCTION_TCC
-#define _TR1_BESSEL_FUNCTION_TCC 1
+#ifndef _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
+#define _GLIBCXX_TR1_BESSEL_FUNCTION_TCC 1
#include "special_function_util.h"
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
_Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
{
#if _GLIBCXX_USE_C99_MATH_TR1
- __gampl = _Tp(1) / std::_GLIBCXX_TR1::tgamma(_Tp(1) + __mu);
- __gammi = _Tp(1) / std::_GLIBCXX_TR1::tgamma(_Tp(1) - __mu);
+ __gampl = _Tp(1) / std::tr1::tgamma(_Tp(1) + __mu);
+ __gammi = _Tp(1) / std::tr1::tgamma(_Tp(1) - __mu);
#else
__gampl = _Tp(1) / __gamma(_Tp(1) + __mu);
__gammi = _Tp(1) / __gamma(_Tp(1) - __mu);
const _Tp __gam = (__p - __f) / __q;
__Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));
#if _GLIBCXX_USE_C99_MATH_TR1
- __Jmu = std::_GLIBCXX_TR1::copysign(__Jmu, __Jnul);
+ __Jmu = std::tr1::copysign(__Jmu, __Jnul);
#else
if (__Jmu * __Jnul < _Tp(0))
__Jmu = -__Jmu;
const _Tp __x2 = __x / _Tp(2);
_Tp __fact = __nu * std::log(__x2);
#if _GLIBCXX_USE_C99_MATH_TR1
- __fact -= std::_GLIBCXX_TR1::lgamma(__nu + _Tp(1));
+ __fact -= std::tr1::lgamma(__nu + _Tp(1));
#else
__fact -= __log_gamma(__nu + _Tp(1));
#endif
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_BESSEL_FUNCTION_TCC
+#endif // _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
// (4) Gamma, Exploring Euler's Constant, Julian Havil,
// Princeton, 2003.
-#ifndef _TR1_BETA_FUNCTION_TCC
-#define _TR1_BETA_FUNCTION_TCC 1
+#ifndef _GLIBCXX_TR1_BETA_FUNCTION_TCC
+#define _GLIBCXX_TR1_BETA_FUNCTION_TCC 1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
#if _GLIBCXX_USE_C99_MATH_TR1
if (__x > __y)
{
- __bet = std::_GLIBCXX_TR1::tgamma(__x)
- / std::_GLIBCXX_TR1::tgamma(__x + __y);
- __bet *= std::_GLIBCXX_TR1::tgamma(__y);
+ __bet = std::tr1::tgamma(__x)
+ / std::tr1::tgamma(__x + __y);
+ __bet *= std::tr1::tgamma(__y);
}
else
{
- __bet = std::_GLIBCXX_TR1::tgamma(__y)
- / std::_GLIBCXX_TR1::tgamma(__x + __y);
- __bet *= std::_GLIBCXX_TR1::tgamma(__x);
+ __bet = std::tr1::tgamma(__y)
+ / std::tr1::tgamma(__x + __y);
+ __bet *= std::tr1::tgamma(__x);
}
#else
if (__x > __y)
__beta_lgamma(_Tp __x, _Tp __y)
{
#if _GLIBCXX_USE_C99_MATH_TR1
- _Tp __bet = std::_GLIBCXX_TR1::lgamma(__x)
- + std::_GLIBCXX_TR1::lgamma(__y)
- - std::_GLIBCXX_TR1::lgamma(__x + __y);
+ _Tp __bet = std::tr1::lgamma(__x)
+ + std::tr1::lgamma(__y)
+ - std::tr1::lgamma(__x + __y);
#else
_Tp __bet = __log_gamma(__x)
+ __log_gamma(__y)
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_BETA_FUNCTION_TCC
+#endif // __GLIBCXX_TR1_BETA_FUNCTION_TCC
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CCOMPLEX
-#define _TR1_CCOMPLEX 1
+#ifndef _GLIBCXX_TR1_CCOMPLEX
+#define _GLIBCXX_TR1_CCOMPLEX 1
#include <tr1/complex>
-#endif
+#endif // _GLIBCXX_TR1_CCOMPLEX
// TR1 cctype -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CCTYPE
-#define _TR1_CCTYPE 1
+#ifndef _GLIBCXX_TR1_CCTYPE
+#define _GLIBCXX_TR1_CCTYPE 1
#include <bits/c++config.h>
#include <cctype>
-#if _GLIBCXX_USE_C99_CTYPE_TR1
-
-#undef isblank
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- using ::isblank;
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cctype>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cctype>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CCTYPE
-// TR1 cctype -*- C++ -*-
+// TR1 cfenv -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CFENV
-#define _TR1_CFENV 1
+#ifndef _GLIBCXX_TR1_CFENV
+#define _GLIBCXX_TR1_CFENV 1
#include <bits/c++config.h>
-#if _GLIBCXX_USE_C99_FENV_TR1
-
-#include_next <fenv.h>
-
-#undef feclearexcept
-#undef fegetexceptflag
-#undef feraiseexcept
-#undef fesetexceptflag
-#undef fetestexcept
-#undef fegetround
-#undef fesetround
-#undef fegetenv
-#undef feholdexcept
-#undef fesetenv
-#undef feupdateenv
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // types
- using ::fenv_t;
- using ::fexcept_t;
-
- // functions
- using ::feclearexcept;
- using ::fegetexceptflag;
- using ::feraiseexcept;
- using ::fesetexceptflag;
- using ::fetestexcept;
-
- using ::fegetround;
- using ::fesetround;
-
- using ::fegetenv;
- using ::feholdexcept;
- using ::fesetenv;
- using ::feupdateenv;
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cfenv>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cfenv>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CFENV
// TR1 cfloat -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CFLOAT
-#define _TR1_CFLOAT 1
+#ifndef _GLIBCXX_TR1_CFLOAT
+#define _GLIBCXX_TR1_CFLOAT 1
#include <cfloat>
#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
#endif
-#endif
+#endif //_GLIBCXX_TR1_CFLOAT
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CINTTYPES
-#define _TR1_CINTTYPES 1
+#ifndef _GLIBCXX_TR1_CINTTYPES
+#define _GLIBCXX_TR1_CINTTYPES 1
-#include <bits/c++config.h>
#include <tr1/cstdint>
-#if _GLIBCXX_USE_C99_INTTYPES_TR1
-
-// For 8.11.1/1 (see C99, Note 184)
-#define __STDC_FORMAT_MACROS
-#include_next <inttypes.h>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // types
- using ::imaxdiv_t;
-
- // functions
- using ::imaxabs;
-
- // May collide with _Longlong abs(_Longlong), and is not described
- // anywhere outside the synopsis. Likely, a defect.
- //
- // intmax_t abs(intmax_t)
-
- using ::imaxdiv;
-
- // Likewise, with lldiv_t div(_Longlong, _Longlong).
- //
- // imaxdiv_t div(intmax_t, intmax_t)
-
- using ::strtoimax;
- using ::strtoumax;
-
-#ifdef _GLIBCXX_USE_WCHAR_T
- using ::wcstoimax;
- using ::wcstoumax;
-#endif
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cinttypes>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cinttypes>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CINTTYPES
// TR1 climits -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CLIMITS
-#define _TR1_CLIMITS 1
+#ifndef _GLIBCXX_TR1_CLIMITS
+#define _GLIBCXX_TR1_CLIMITS 1
#include <climits>
#define ULLONG_MAX __LONG_LONG_MAX__ * 2ULL + 1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CLIMITS
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CMATH
-#define _TR1_CMATH 1
+#ifndef _GLIBCXX_TR1_CMATH
+#define _GLIBCXX_TR1_CMATH 1
-#include <bits/c++config.h>
-#include <bits/stl_algobase.h>
-#include <limits>
-#include <cmath>
-#include <tr1/common.h>
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
-#undef acosh
-#undef acoshf
-#undef acoshl
-#undef asinh
-#undef asinhf
-#undef asinhl
-#undef atanh
-#undef atanhf
-#undef atanhl
-#undef cbrt
-#undef cbrtf
-#undef cbrtl
-#undef copysign
-#undef copysignf
-#undef copysignl
-#undef erf
-#undef erff
-#undef erfl
-#undef erfc
-#undef erfcf
-#undef erfcl
-#undef exp2
-#undef exp2f
-#undef exp2l
-#undef expm1
-#undef expm1f
-#undef expm1l
-#undef fdim
-#undef fdimf
-#undef fdiml
-#undef fma
-#undef fmaf
-#undef fmal
-#undef fmax
-#undef fmaxf
-#undef fmaxl
-#undef fmin
-#undef fminf
-#undef fminl
-#undef hypot
-#undef hypotf
-#undef hypotl
-#undef ilogb
-#undef ilogbf
-#undef ilogbl
-#undef lgamma
-#undef lgammaf
-#undef lgammal
-#undef llrint
-#undef llrintf
-#undef llrintl
-#undef llround
-#undef llroundf
-#undef llroundl
-#undef log1p
-#undef log1pf
-#undef log1pl
-#undef log2
-#undef log2f
-#undef log2l
-#undef logb
-#undef logbf
-#undef logbl
-#undef lrint
-#undef lrintf
-#undef lrintl
-#undef lround
-#undef lroundf
-#undef lroundl
-#undef nan
-#undef nanf
-#undef nanl
-#undef nearbyint
-#undef nearbyintf
-#undef nearbyintl
-#undef nextafter
-#undef nextafterf
-#undef nextafterl
-#undef nexttoward
-#undef nexttowardf
-#undef nexttowardl
-#undef remainder
-#undef remainderf
-#undef remainderl
-#undef remquo
-#undef remquo
-#undef remquo
-#undef rint
-#undef rintf
-#undef rintl
-#undef round
-#undef roundf
-#undef roundl
-#undef scalbln
-#undef scalblnf
-#undef scalblnl
-#undef scalbn
-#undef scalbnf
-#undef scalbnl
-#undef tgamma
-#undef tgammaf
-#undef tgammal
-#undef trunc
-#undef truncf
-#undef truncl
+#pragma GCC system_header
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
#endif
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
- // types
- using ::double_t;
- using ::float_t;
-
- // functions
- using ::acosh;
- using ::acoshf;
- using ::acoshl;
-
- using ::asinh;
- using ::asinhf;
- using ::asinhl;
-
- using ::atanh;
- using ::atanhf;
- using ::atanhl;
-
- using ::cbrt;
- using ::cbrtf;
- using ::cbrtl;
-
- using ::copysign;
- using ::copysignf;
- using ::copysignl;
-
- using ::erf;
- using ::erff;
- using ::erfl;
-
- using ::erfc;
- using ::erfcf;
- using ::erfcl;
-
- using ::exp2;
- using ::exp2f;
- using ::exp2l;
-
- using ::expm1;
- using ::expm1f;
- using ::expm1l;
-
- using ::fdim;
- using ::fdimf;
- using ::fdiml;
-
- using ::fma;
- using ::fmaf;
- using ::fmal;
-
- using ::fmax;
- using ::fmaxf;
- using ::fmaxl;
-
- using ::fmin;
- using ::fminf;
- using ::fminl;
-
- using ::hypot;
- using ::hypotf;
- using ::hypotl;
-
- using ::ilogb;
- using ::ilogbf;
- using ::ilogbl;
-
- using ::lgamma;
- using ::lgammaf;
- using ::lgammal;
-
- using ::llrint;
- using ::llrintf;
- using ::llrintl;
-
- using ::llround;
- using ::llroundf;
- using ::llroundl;
-
- using ::log1p;
- using ::log1pf;
- using ::log1pl;
-
- using ::log2;
- using ::log2f;
- using ::log2l;
-
- using ::logb;
- using ::logbf;
- using ::logbl;
-
- using ::lrint;
- using ::lrintf;
- using ::lrintl;
-
- using ::lround;
- using ::lroundf;
- using ::lroundl;
-
- using ::nan;
- using ::nanf;
- using ::nanl;
-
- using ::nearbyint;
- using ::nearbyintf;
- using ::nearbyintl;
-
- using ::nextafter;
- using ::nextafterf;
- using ::nextafterl;
-
- using ::nexttoward;
- using ::nexttowardf;
- using ::nexttowardl;
-
- using ::remainder;
- using ::remainderf;
- using ::remainderl;
-
- using ::remquo;
- using ::remquo;
- using ::remquo;
-
- using ::rint;
- using ::rintf;
- using ::rintl;
-
- using ::round;
- using ::roundf;
- using ::roundl;
-
- using ::scalbln;
- using ::scalblnf;
- using ::scalblnl;
-
- using ::scalbn;
- using ::scalbnf;
- using ::scalbnl;
-
- using ::tgamma;
- using ::tgammaf;
- using ::tgammal;
-
- using ::trunc;
- using ::truncf;
- using ::truncl;
-
-#endif
-
-#if _GLIBCXX_USE_C99_MATH
-#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-
- /// @brief Function template definitions [8.16.3].
- //
- using std::signbit;
-
- using std::fpclassify;
-
- using std::isfinite;
- using std::isinf;
- using std::isnan;
- using std::isnormal;
-
- using std::isgreater;
- using std::isgreaterequal;
- using std::isless;
- using std::islessequal;
- using std::islessgreater;
- using std::isunordered;
-#endif
-#endif
-
-#if _GLIBCXX_USE_C99_MATH_TR1
-
- /// @brief Additional overloads [8.16.4].
- //
- using std::acos;
-
- inline float
- acosh(float __x)
- { return __builtin_acoshf(__x); }
-
- inline long double
- acosh(long double __x)
- { return __builtin_acoshl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- acosh(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return acosh(__type(__x));
- }
-
- using std::asin;
-
- inline float
- asinh(float __x)
- { return __builtin_asinhf(__x); }
-
- inline long double
- asinh(long double __x)
- { return __builtin_asinhl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- asinh(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return asinh(__type(__x));
- }
-
- using std::atan;
-
- // Workaround for c++/21682.
- namespace __detail
- {
- template<typename _Tp, typename _Up>
- inline typename
- __gnu_cxx::__enable_if<std::__is_floating<_Tp>::__value
- || std::__is_floating<_Up>::__value,
- typename std::_GLIBCXX_TR1::
- __promote_2<_Tp, _Up>::__type>::__type
- atan2(_Tp __y, _Up __x)
- {
- typedef typename std::_GLIBCXX_TR1::__promote_2<_Tp, _Up>::__type
- __type;
- return std::atan2(__type(__y), __type(__x));
- }
- } // namespace __detail
-
- using std::atan2;
- using __detail::atan2;
-
- inline float
- atanh(float __x)
- { return __builtin_atanhf(__x); }
-
- inline long double
- atanh(long double __x)
- { return __builtin_atanhl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- atanh(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return atanh(__type(__x));
- }
-
- inline float
- cbrt(float __x)
- { return __builtin_cbrtf(__x); }
-
- inline long double
- cbrt(long double __x)
- { return __builtin_cbrtl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- cbrt(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return cbrt(__type(__x));
- }
-
- using std::ceil;
-
- inline float
- copysign(float __x, float __y)
- { return __builtin_copysignf(__x, __y); }
-
- inline long double
- copysign(long double __x, long double __y)
- { return __builtin_copysignl(__x, __y); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- copysign(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return copysign(__type(__x), __type(__y));
- }
-
- using std::cos;
- using std::cosh;
-
- inline float
- erf(float __x)
- { return __builtin_erff(__x); }
-
- inline long double
- erf(long double __x)
- { return __builtin_erfl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- erf(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return erf(__type(__x));
- }
-
- inline float
- erfc(float __x)
- { return __builtin_erfcf(__x); }
-
- inline long double
- erfc(long double __x)
- { return __builtin_erfcl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- erfc(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return erfc(__type(__x));
- }
-
- using std::exp;
-
- inline float
- exp2(float __x)
- { return __builtin_exp2f(__x); }
-
- inline long double
- exp2(long double __x)
- { return __builtin_exp2l(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- exp2(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return exp2(__type(__x));
- }
-
- inline float
- expm1(float __x)
- { return __builtin_expm1f(__x); }
-
- inline long double
- expm1(long double __x)
- { return __builtin_expm1l(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- expm1(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return expm1(__type(__x));
- }
-
- using std::fabs;
-
- inline float
- fdim(float __x, float __y)
- { return __builtin_fdimf(__x, __y); }
-
- inline long double
- fdim(long double __x, long double __y)
- { return __builtin_fdiml(__x, __y); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- fdim(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return fdim(__type(__x), __type(__y));
- }
-
- using std::floor;
-
- inline float
- fma(float __x, float __y, float __z)
- { return __builtin_fmaf(__x, __y, __z); }
-
- inline long double
- fma(long double __x, long double __y, long double __z)
- { return __builtin_fmal(__x, __y, __z); }
-
- template<typename _Tp, typename _Up, typename _Vp>
- inline typename __promote_3<_Tp, _Up, _Vp>::__type
- fma(_Tp __x, _Up __y, _Vp __z)
- {
- typedef typename __promote_3<_Tp, _Up, _Vp>::__type __type;
- return fma(__type(__x), __type(__y), __type(__z));
- }
-
- inline float
- fmax(float __x, float __y)
- { return __builtin_fmaxf(__x, __y); }
-
- inline long double
- fmax(long double __x, long double __y)
- { return __builtin_fmaxl(__x, __y); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- fmax(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return fmax(__type(__x), __type(__y));
- }
-
- inline float
- fmin(float __x, float __y)
- { return __builtin_fminf(__x, __y); }
-
- inline long double
- fmin(long double __x, long double __y)
- { return __builtin_fminl(__x, __y); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- fmin(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return fmin(__type(__x), __type(__y));
- }
-
- using std::fmod;
- using std::frexp;
-
- inline float
- hypot(float __x, float __y)
- { return __builtin_hypotf(__x, __y); }
-
- inline long double
- hypot(long double __x, long double __y)
- { return __builtin_hypotl(__x, __y); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- hypot(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return hypot(__type(__x), __type(__y));
- }
-
- inline int
- ilogb(float __x)
- { return __builtin_ilogbf(__x); }
-
- inline int
- ilogb(long double __x)
- { return __builtin_ilogbl(__x); }
-
- template<typename _Tp>
- inline int
- ilogb(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return ilogb(__type(__x));
- }
-
- using std::ldexp;
-
- inline float
- lgamma(float __x)
- { return __builtin_lgammaf(__x); }
-
- inline long double
- lgamma(long double __x)
- { return __builtin_lgammal(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- lgamma(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return lgamma(__type(__x));
- }
-
- inline long long
- llrint(float __x)
- { return __builtin_llrintf(__x); }
-
- inline long long
- llrint(long double __x)
- { return __builtin_llrintl(__x); }
-
- template<typename _Tp>
- inline long long
- llrint(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return llrint(__type(__x));
- }
-
- inline long long
- llround(float __x)
- { return __builtin_llroundf(__x); }
-
- inline long long
- llround(long double __x)
- { return __builtin_llroundl(__x); }
-
- template<typename _Tp>
- inline long long
- llround(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return llround(__type(__x));
- }
-
- using std::log;
- using std::log10;
-
- inline float
- log1p(float __x)
- { return __builtin_log1pf(__x); }
-
- inline long double
- log1p(long double __x)
- { return __builtin_log1pl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- log1p(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return log1p(__type(__x));
- }
-
- // DR 568.
- inline float
- log2(float __x)
- { return __builtin_log2f(__x); }
-
- inline long double
- log2(long double __x)
- { return __builtin_log2l(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- log2(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return log2(__type(__x));
- }
-
- inline float
- logb(float __x)
- { return __builtin_logbf(__x); }
-
- inline long double
- logb(long double __x)
- { return __builtin_logbl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- logb(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return logb(__type(__x));
- }
-
- inline long
- lrint(float __x)
- { return __builtin_lrintf(__x); }
-
- inline long
- lrint(long double __x)
- { return __builtin_lrintl(__x); }
-
- template<typename _Tp>
- inline long
- lrint(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return lrint(__type(__x));
- }
-
- inline long
- lround(float __x)
- { return __builtin_lroundf(__x); }
-
- inline long
- lround(long double __x)
- { return __builtin_lroundl(__x); }
-
- template<typename _Tp>
- inline long
- lround(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return lround(__type(__x));
- }
-
- inline float
- nearbyint(float __x)
- { return __builtin_nearbyintf(__x); }
-
- inline long double
- nearbyint(long double __x)
- { return __builtin_nearbyintl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- nearbyint(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return nearbyint(__type(__x));
- }
-
- inline float
- nextafter(float __x, float __y)
- { return __builtin_nextafterf(__x, __y); }
-
- inline long double
- nextafter(long double __x, long double __y)
- { return __builtin_nextafterl(__x, __y); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- nextafter(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return nextafter(__type(__x), __type(__y));
- }
-
- inline float
- nexttoward(float __x, long double __y)
- { return __builtin_nexttowardf(__x, __y); }
-
- inline long double
- nexttoward(long double __x, long double __y)
- { return __builtin_nexttowardl(__x, __y); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- nexttoward(_Tp __x, long double __y)
- {
- typedef typename __promote<_Tp>::__type __type;
- return nexttoward(__type(__x), __y);
- }
-
- using std::pow;
-
- // DR 550.
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- pow(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return pow(__type(__x), __type(__y));
- }
-
- inline float
- remainder(float __x, float __y)
- { return __builtin_remainderf(__x, __y); }
-
- inline long double
- remainder(long double __x, long double __y)
- { return __builtin_remainderl(__x, __y); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- remainder(_Tp __x, _Up __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return remainder(__type(__x), __type(__y));
- }
-
- inline float
- remquo(float __x, float __y, int* __pquo)
- { return __builtin_remquof(__x, __y, __pquo); }
-
- inline long double
- remquo(long double __x, long double __y, int* __pquo)
- { return __builtin_remquol(__x, __y, __pquo); }
-
- template<typename _Tp, typename _Up>
- inline typename __promote_2<_Tp, _Up>::__type
- remquo(_Tp __x, _Up __y, int* __pquo)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return remquo(__type(__x), __type(__y), __pquo);
- }
-
- inline float
- rint(float __x)
- { return __builtin_rintf(__x); }
-
- inline long double
- rint(long double __x)
- { return __builtin_rintl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- rint(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return rint(__type(__x));
- }
-
- inline float
- round(float __x)
- { return __builtin_roundf(__x); }
-
- inline long double
- round(long double __x)
- { return __builtin_roundl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- round(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return round(__type(__x));
- }
-
- inline float
- scalbln(float __x, long __ex)
- { return __builtin_scalblnf(__x, __ex); }
-
- inline long double
- scalbln(long double __x, long __ex)
- { return __builtin_scalblnl(__x, __ex); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- scalbln(_Tp __x, long __ex)
- {
- typedef typename __promote<_Tp>::__type __type;
- return scalbln(__type(__x), __ex);
- }
-
- inline float
- scalbn(float __x, int __ex)
- { return __builtin_scalbnf(__x, __ex); }
-
- inline long double
- scalbn(long double __x, int __ex)
- { return __builtin_scalbnl(__x, __ex); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- scalbn(_Tp __x, int __ex)
- {
- typedef typename __promote<_Tp>::__type __type;
- return scalbn(__type(__x), __ex);
- }
-
- using std::sin;
- using std::sinh;
- using std::sqrt;
- using std::tan;
- using std::tanh;
-
- inline float
- tgamma(float __x)
- { return __builtin_tgammaf(__x); }
-
- inline long double
- tgamma(long double __x)
- { return __builtin_tgammal(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- tgamma(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return tgamma(__type(__x));
- }
-
- inline float
- trunc(float __x)
- { return __builtin_truncf(__x); }
-
- inline long double
- trunc(long double __x)
- { return __builtin_truncl(__x); }
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- trunc(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return trunc(__type(__x));
- }
-
+#include <cmath>
+#include <ext/type_traits.h>
+#include <tr1/type_traits>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cmath>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cmath>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-_GLIBCXX_END_NAMESPACE
-}
-
-
/**
* @defgroup tr1_math_spec_func Mathematical Special Functions
* A collection of advanced mathematical special functions.
* @{
*/
#ifndef __GXX_EXPERIMENTAL_CXX0X__
+#include <bits/stl_algobase.h>
+#include <limits>
+
#include <tr1/gamma.tcc>
#include <tr1/bessel_function.tcc>
#include <tr1/beta_function.tcc>
// namespace std::tr1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
+namespace tr1
+{
// 5.2.1.1 Associated Laguerre polynomials.
inline float
}
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__assoc_laguerre<__type>(__n, __m, __x);
}
{ return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
}
{ return __detail::__beta<long double>(__x, __y); }
template<typename _Tpx, typename _Tpy>
- inline typename __promote_2<_Tpx, _Tpy>::__type
+ inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type
beta(_Tpx __x, _Tpy __y)
{
- typedef typename __promote_2<_Tpx, _Tpy>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type;
return __detail::__beta<__type>(__x, __y);
}
{ return __detail::__comp_ellint_1<long double>(__k); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
comp_ellint_1(_Tp __k)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__comp_ellint_1<__type>(__k);
}
{ return __detail::__comp_ellint_2<long double>(__k); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
comp_ellint_2(_Tp __k)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__comp_ellint_2<__type>(__k);
}
{ return __detail::__comp_ellint_3<long double>(__k, __nu); }
template<typename _Tp, typename _Tpn>
- inline typename __promote_2<_Tp, _Tpn>::__type
+ inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
comp_ellint_3(_Tp __k, _Tpn __nu)
{
- typedef typename __promote_2<_Tp, _Tpn>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
return __detail::__comp_ellint_3<__type>(__k, __nu);
}
{ return __detail::__conf_hyperg<long double>(__a, __c, __x); }
template<typename _Tpa, typename _Tpc, typename _Tp>
- inline typename __promote_3<_Tpa, _Tpc, _Tp>::__type
+ inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
{
- typedef typename __promote_3<_Tpa, _Tpc, _Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
return __detail::__conf_hyperg<__type>(__a, __c, __x);
}
{ return __detail::__cyl_bessel_i<long double>(__nu, __x); }
template<typename _Tpnu, typename _Tp>
- inline typename __promote_2<_Tpnu, _Tp>::__type
+ inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
cyl_bessel_i(_Tpnu __nu, _Tp __x)
{
- typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
return __detail::__cyl_bessel_i<__type>(__nu, __x);
}
{ return __detail::__cyl_bessel_j<long double>(__nu, __x); }
template<typename _Tpnu, typename _Tp>
- inline typename __promote_2<_Tpnu, _Tp>::__type
+ inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
cyl_bessel_j(_Tpnu __nu, _Tp __x)
{
- typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
return __detail::__cyl_bessel_j<__type>(__nu, __x);
}
{ return __detail::__cyl_bessel_k<long double>(__nu, __x); }
template<typename _Tpnu, typename _Tp>
- inline typename __promote_2<_Tpnu, _Tp>::__type
+ inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
cyl_bessel_k(_Tpnu __nu, _Tp __x)
{
- typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
return __detail::__cyl_bessel_k<__type>(__nu, __x);
}
{ return __detail::__cyl_neumann_n<long double>(__nu, __x); }
template<typename _Tpnu, typename _Tp>
- inline typename __promote_2<_Tpnu, _Tp>::__type
+ inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
cyl_neumann(_Tpnu __nu, _Tp __x)
{
- typedef typename __promote_2<_Tpnu, _Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
return __detail::__cyl_neumann_n<__type>(__nu, __x);
}
{ return __detail::__ellint_1<long double>(__k, __phi); }
template<typename _Tp, typename _Tpp>
- inline typename __promote_2<_Tp, _Tpp>::__type
+ inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
ellint_1(_Tp __k, _Tpp __phi)
{
- typedef typename __promote_2<_Tp, _Tpp>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
return __detail::__ellint_1<__type>(__k, __phi);
}
{ return __detail::__ellint_2<long double>(__k, __phi); }
template<typename _Tp, typename _Tpp>
- inline typename __promote_2<_Tp, _Tpp>::__type
+ inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
ellint_2(_Tp __k, _Tpp __phi)
{
- typedef typename __promote_2<_Tp, _Tpp>::__type __type;
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
return __detail::__ellint_2<__type>(__k, __phi);
}
{ return __detail::__ellint_3<long double>(__k, __nu, __phi); }
template<typename _Tp, typename _Tpn, typename _Tpp>
- inline typename __promote_3<_Tp, _Tpn, _Tpp>::__type
+ inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
{
- typedef typename __promote_3<_Tp, _Tpn, _Tpp>::__type __type;
+ typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
return __detail::__ellint_3<__type>(__k, __nu, __phi);
}
{ return __detail::__expint<long double>(__x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
expint(_Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__expint<__type>(__x);
}
{ return __detail::__poly_hermite<long double>(__n, __x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
hermite(unsigned int __n, _Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__poly_hermite<__type>(__n, __x);
}
{ return __detail::__hyperg<long double>(__a, __b, __c, __x); }
template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
- inline typename __promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
+ inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
{
- typedef typename __promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
return __detail::__hyperg<__type>(__a, __b, __c, __x);
}
{ return __detail::__laguerre<long double>(__n, __x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
laguerre(unsigned int __n, _Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__laguerre<__type>(__n, __x);
}
{ return __detail::__poly_legendre_p<long double>(__n, __x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
legendre(unsigned int __n, _Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__poly_legendre_p<__type>(__n, __x);
}
{ return __detail::__riemann_zeta<long double>(__x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
riemann_zeta(_Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__riemann_zeta<__type>(__x);
}
{ return __detail::__sph_bessel<long double>(__n, __x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
sph_bessel(unsigned int __n, _Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__sph_bessel<__type>(__n, __x);
}
{ return __detail::__sph_legendre<long double>(__l, __m, __theta); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__sph_legendre<__type>(__l, __m, __theta);
}
{ return __detail::__sph_neumann<long double>(__n, __x); }
template<typename _Tp>
- inline typename __promote<_Tp>::__type
+ inline typename __gnu_cxx::__promote<_Tp>::__type
sph_neumann(unsigned int __n, _Tp __x)
{
- typedef typename __promote<_Tp>::__type __type;
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __detail::__sph_neumann<__type>(__n, __x);
}
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
#endif // __GXX_EXPERIMENTAL_CXX0X__
-#endif
+#endif // _GLIBCXX_TR1_CMATH
+++ /dev/null
-// Internal header for TR1 complex -*- C++ -*-
-
-// Copyright (C) 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
-
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING. If not, write to the Free
-// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-// USA.
-
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
-
-/** @file tr1/common.h
- * This is a TR1 C++ Library header.
- */
-
-#ifndef _TR1_COMMON_H
-#define _TR1_COMMON_H 1
-
-#include <tr1/type_traits>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- template<typename _Tp, bool = is_integral<_Tp>::value>
- struct __promote
- { typedef double __type; };
-
- template<typename _Tp>
- struct __promote<_Tp, false>
- { typedef _Tp __type; };
-
- template<typename _Tp, typename _Up>
- struct __promote_2
- {
- private:
- typedef typename __promote<_Tp>::__type __type1;
- typedef typename __promote<_Up>::__type __type2;
-
- public:
- typedef __typeof__(__type1() + __type2()) __type;
- };
-
- template<typename _Tp, typename _Up, typename _Vp>
- struct __promote_3
- {
- private:
- typedef typename __promote<_Tp>::__type __type1;
- typedef typename __promote<_Up>::__type __type2;
- typedef typename __promote<_Vp>::__type __type3;
-
- public:
- typedef __typeof__(__type1() + __type2() + __type3()) __type;
- };
-
- template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
- struct __promote_4
- {
- private:
- typedef typename __promote<_Tp>::__type __type1;
- typedef typename __promote<_Up>::__type __type2;
- typedef typename __promote<_Vp>::__type __type3;
- typedef typename __promote<_Wp>::__type __type4;
-
- public:
- typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
- };
-
-_GLIBCXX_END_NAMESPACE
-} // namespace std
-
-#endif
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_COMPLEX
-#define _TR1_COMPLEX 1
+#ifndef _GLIBCXX_TR1_COMPLEX
+#define _GLIBCXX_TR1_COMPLEX 1
-#include <complex>
-#include <tr1/common.h>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // Forward declarations.
- template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
- template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
- template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
-
- template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
- template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
- template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
- template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
-
- /// @brief acos(__z) [8.1.2].
- // Effects: Behaves the same as C99 function cacos, defined
- // in subclause 7.3.5.1.
- template<typename _Tp>
- inline std::complex<_Tp>
- __complex_acos(const std::complex<_Tp>& __z)
- {
- const std::complex<_Tp> __t = std::_GLIBCXX_TR1::asin(__z);
- const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
- return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
- }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
- inline __complex__ float
- __complex_acos(__complex__ float __z)
- { return __builtin_cacosf(__z); }
-
- inline __complex__ double
- __complex_acos(__complex__ double __z)
- { return __builtin_cacos(__z); }
-
- inline __complex__ long double
- __complex_acos(const __complex__ long double& __z)
- { return __builtin_cacosl(__z); }
-
- template<typename _Tp>
- inline std::complex<_Tp>
- acos(const std::complex<_Tp>& __z)
- { return __complex_acos(__z.__rep()); }
-#else
- template<typename _Tp>
- inline std::complex<_Tp>
- acos(const std::complex<_Tp>& __z)
- { return __complex_acos(__z); }
-#endif
-
- /// @brief asin(__z) [8.1.3].
- // Effects: Behaves the same as C99 function casin, defined
- // in subclause 7.3.5.2.
- template<typename _Tp>
- inline std::complex<_Tp>
- __complex_asin(const std::complex<_Tp>& __z)
- {
- std::complex<_Tp> __t(-__z.imag(), __z.real());
- __t = std::_GLIBCXX_TR1::asinh(__t);
- return std::complex<_Tp>(__t.imag(), -__t.real());
- }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
- inline __complex__ float
- __complex_asin(__complex__ float __z)
- { return __builtin_casinf(__z); }
-
- inline __complex__ double
- __complex_asin(__complex__ double __z)
- { return __builtin_casin(__z); }
-
- inline __complex__ long double
- __complex_asin(const __complex__ long double& __z)
- { return __builtin_casinl(__z); }
-
- template<typename _Tp>
- inline std::complex<_Tp>
- asin(const std::complex<_Tp>& __z)
- { return __complex_asin(__z.__rep()); }
-#else
- template<typename _Tp>
- inline std::complex<_Tp>
- asin(const std::complex<_Tp>& __z)
- { return __complex_asin(__z); }
-#endif
-
- /// @brief atan(__z) [8.1.4].
- // Effects: Behaves the same as C99 function catan, defined
- // in subclause 7.3.5.3.
- template<typename _Tp>
- std::complex<_Tp>
- __complex_atan(const std::complex<_Tp>& __z)
- {
- const _Tp __r2 = __z.real() * __z.real();
- const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
-
- _Tp __num = __z.imag() + _Tp(1.0);
- _Tp __den = __z.imag() - _Tp(1.0);
-
- __num = __r2 + __num * __num;
- __den = __r2 + __den * __den;
-
- return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
- _Tp(0.25) * log(__num / __den));
- }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
- inline __complex__ float
- __complex_atan(__complex__ float __z)
- { return __builtin_catanf(__z); }
-
- inline __complex__ double
- __complex_atan(__complex__ double __z)
- { return __builtin_catan(__z); }
-
- inline __complex__ long double
- __complex_atan(const __complex__ long double& __z)
- { return __builtin_catanl(__z); }
-
- template<typename _Tp>
- inline std::complex<_Tp>
- atan(const std::complex<_Tp>& __z)
- { return __complex_atan(__z.__rep()); }
-#else
- template<typename _Tp>
- inline std::complex<_Tp>
- atan(const std::complex<_Tp>& __z)
- { return __complex_atan(__z); }
-#endif
-
- /// @brief acosh(__z) [8.1.5].
- // Effects: Behaves the same as C99 function cacosh, defined
- // in subclause 7.3.6.1.
- template<typename _Tp>
- std::complex<_Tp>
- __complex_acosh(const std::complex<_Tp>& __z)
- {
- std::complex<_Tp> __t((__z.real() - __z.imag())
- * (__z.real() + __z.imag()) - _Tp(1.0),
- _Tp(2.0) * __z.real() * __z.imag());
- __t = std::sqrt(__t);
-
- return std::log(__t + __z);
- }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
- inline __complex__ float
- __complex_acosh(__complex__ float __z)
- { return __builtin_cacoshf(__z); }
-
- inline __complex__ double
- __complex_acosh(__complex__ double __z)
- { return __builtin_cacosh(__z); }
-
- inline __complex__ long double
- __complex_acosh(const __complex__ long double& __z)
- { return __builtin_cacoshl(__z); }
-
- template<typename _Tp>
- inline std::complex<_Tp>
- acosh(const std::complex<_Tp>& __z)
- { return __complex_acosh(__z.__rep()); }
-#else
- template<typename _Tp>
- inline std::complex<_Tp>
- acosh(const std::complex<_Tp>& __z)
- { return __complex_acosh(__z); }
-#endif
-
- /// @brief asinh(__z) [8.1.6].
- // Effects: Behaves the same as C99 function casin, defined
- // in subclause 7.3.6.2.
- template<typename _Tp>
- std::complex<_Tp>
- __complex_asinh(const std::complex<_Tp>& __z)
- {
- std::complex<_Tp> __t((__z.real() - __z.imag())
- * (__z.real() + __z.imag()) + _Tp(1.0),
- _Tp(2.0) * __z.real() * __z.imag());
- __t = std::sqrt(__t);
+#pragma GCC system_header
- return std::log(__t + __z);
- }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
- inline __complex__ float
- __complex_asinh(__complex__ float __z)
- { return __builtin_casinhf(__z); }
-
- inline __complex__ double
- __complex_asinh(__complex__ double __z)
- { return __builtin_casinh(__z); }
-
- inline __complex__ long double
- __complex_asinh(const __complex__ long double& __z)
- { return __builtin_casinhl(__z); }
-
- template<typename _Tp>
- inline std::complex<_Tp>
- asinh(const std::complex<_Tp>& __z)
- { return __complex_asinh(__z.__rep()); }
-#else
- template<typename _Tp>
- inline std::complex<_Tp>
- asinh(const std::complex<_Tp>& __z)
- { return __complex_asinh(__z); }
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
#endif
- /// @brief atanh(__z) [8.1.7].
- // Effects: Behaves the same as C99 function catanh, defined
- // in subclause 7.3.6.3.
- template<typename _Tp>
- std::complex<_Tp>
- __complex_atanh(const std::complex<_Tp>& __z)
- {
- const _Tp __i2 = __z.imag() * __z.imag();
- const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
-
- _Tp __num = _Tp(1.0) + __z.real();
- _Tp __den = _Tp(1.0) - __z.real();
-
- __num = __i2 + __num * __num;
- __den = __i2 + __den * __den;
-
- return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
- _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
- }
-
-#if _GLIBCXX_USE_C99_COMPLEX_TR1
- inline __complex__ float
- __complex_atanh(__complex__ float __z)
- { return __builtin_catanhf(__z); }
-
- inline __complex__ double
- __complex_atanh(__complex__ double __z)
- { return __builtin_catanh(__z); }
-
- inline __complex__ long double
- __complex_atanh(const __complex__ long double& __z)
- { return __builtin_catanhl(__z); }
+#include <complex>
+#include <ext/type_traits.h>
+#include <tr1/type_traits>
- template<typename _Tp>
- inline std::complex<_Tp>
- atanh(const std::complex<_Tp>& __z)
- { return __complex_atanh(__z.__rep()); }
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/complex>
#else
- template<typename _Tp>
- inline std::complex<_Tp>
- atanh(const std::complex<_Tp>& __z)
- { return __complex_atanh(__z); }
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/complex>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
- /// @brief fabs(__z) [8.1.8].
- // Effects: Behaves the same as C99 function cabs, defined
- // in subclause 7.3.8.1.
- template<typename _Tp>
- inline std::complex<_Tp>
- fabs(const std::complex<_Tp>& __z)
- { return std::abs(__z); }
-
-
- /// @brief Additional overloads [8.1.9].
- //
-
- // See common.h for the primary template.
- template<typename _Tp, typename _Up>
- struct __promote_2<std::complex<_Tp>, _Up>
- {
- public:
- typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
- };
-
- template<typename _Tp, typename _Up>
- struct __promote_2<_Tp, std::complex<_Up> >
- {
- public:
- typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
- };
-
- template<typename _Tp, typename _Up>
- struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
- {
- public:
- typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
- };
-
-
+namespace std
+{
+namespace tr1
+{
using std::arg;
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- arg(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return std::arg(std::complex<__type>(__x));
- }
-
using std::conj;
-
- template<typename _Tp>
- inline std::complex<typename __promote<_Tp>::__type>
- conj(_Tp __x)
- { return __x; }
-
using std::imag;
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- imag(_Tp)
- { return _Tp(); }
-
using std::norm;
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- norm(_Tp __x)
- {
- typedef typename __promote<_Tp>::__type __type;
- return __type(__x) * __type(__x);
- }
-
using std::polar;
-
- template<typename _Tp, typename _Up>
- inline std::complex<typename __promote_2<_Tp, _Up>::__type>
- polar(const _Tp& __rho, const _Up& __theta)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return std::polar(__type(__rho), __type(__theta));
- }
-
using std::pow;
-
- template<typename _Tp, typename _Up>
- inline std::complex<typename __promote_2<_Tp, _Up>::__type>
- pow(const std::complex<_Tp>& __x, const _Up& __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return std::pow(std::complex<__type>(__x), __type(__y));
- }
-
- template<typename _Tp, typename _Up>
- inline std::complex<typename __promote_2<_Tp, _Up>::__type>
- pow(const _Tp& __x, const std::complex<_Up>& __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return std::pow(__type(__x), std::complex<__type>(__y));
- }
-
- template<typename _Tp, typename _Up>
- inline std::complex<typename __promote_2<_Tp, _Up>::__type>
- pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
- {
- typedef typename __promote_2<_Tp, _Up>::__type __type;
- return std::pow(std::complex<__type>(__x),
- std::complex<__type>(__y));
- }
-
using std::real;
-
- template<typename _Tp>
- inline typename __promote<_Tp>::__type
- real(_Tp __x)
- { return __x; }
-
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif
+#endif // _GLIBCXX_TR1_COMPLEX
+
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_COMPLEX_H
-#define _TR1_COMPLEX_H 1
+#ifndef _GLIBCXX_TR1_COMPLEX_H
+#define _GLIBCXX_TR1_COMPLEX_H 1
#include <tr1/ccomplex>
-#endif
+#endif // _GLIBCXX_TR1_COMPLEX_H
// TR1 cstdarg -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CSTDARG
-#define _TR1_CSTDARG 1
+#ifndef _GLIBCXX_TR1_CSTDARG
+#define _GLIBCXX_TR1_CSTDARG 1
#include <cstdarg>
-#endif
+#endif // _GLIBCXX_TR1_CSTDARG
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CSTDBOOL
-#define _TR1_CSTDBOOL 1
+#ifndef _GLIBCXX_TR1_CSTDBOOL
+#define _GLIBCXX_TR1_CSTDBOOL 1
#include <bits/c++config.h>
#include_next <stdbool.h>
#endif
-#endif
+#endif // _GLIBCXX_TR1_CSTDBOOL
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CSTDINT
-#define _TR1_CSTDINT 1
+#ifndef _GLIBCXX_TR1_CSTDINT
+#define _GLIBCXX_TR1_CSTDINT 1
-#include <bits/c++config.h>
-
-#if _GLIBCXX_USE_C99_STDINT_TR1
-
-// For 8.22.1/1 (see C99, Notes 219, 220, 222)
-#define __STDC_LIMIT_MACROS
-#define __STDC_CONSTANT_MACROS
-#include_next <stdint.h>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- using ::int8_t;
- using ::int16_t;
- using ::int32_t;
- using ::int64_t;
-
- using ::int_fast8_t;
- using ::int_fast16_t;
- using ::int_fast32_t;
- using ::int_fast64_t;
-
- using ::int_least8_t;
- using ::int_least16_t;
- using ::int_least32_t;
- using ::int_least64_t;
+#pragma GCC system_header
- using ::intmax_t;
- using ::intptr_t;
-
- using ::uint8_t;
- using ::uint16_t;
- using ::uint32_t;
- using ::uint64_t;
-
- using ::uint_fast8_t;
- using ::uint_fast16_t;
- using ::uint_fast32_t;
- using ::uint_fast64_t;
-
- using ::uint_least8_t;
- using ::uint_least16_t;
- using ::uint_least32_t;
- using ::uint_least64_t;
-
- using ::uintmax_t;
- using ::uintptr_t;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
-_GLIBCXX_END_NAMESPACE
-}
+#include <bits/c++config.h>
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cstdint>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cstdint>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CSTDINT
+
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CSTDIO
-#define _TR1_CSTDIO 1
+#ifndef _GLIBCXX_TR1_CSTDIO
+#define _GLIBCXX_TR1_CSTDIO 1
-#include <bits/c++config.h>
-#include <cstdio>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_USE_C99
- using std::snprintf;
- using std::vsnprintf;
+#pragma GCC system_header
- using std::vfscanf;
- using std::vscanf;
- using std::vsscanf;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
#endif
-_GLIBCXX_END_NAMESPACE
-}
+#include <cstdio>
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cstdio>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cstdio>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
+
+#endif // _GLIBCXX_TR1_CSTDIO
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CSTDLIB
-#define _TR1_CSTDLIB 1
+#ifndef _GLIBCXX_TR1_CSTDLIB
+#define _GLIBCXX_TR1_CSTDLIB 1
-#include <bits/c++config.h>
+#pragma GCC system_header
-#if _GLIBCXX_HOSTED
-
-#include <cstdlib>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_USE_C99
-
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
- // types
- using std::lldiv_t;
-
- // functions
- using std::llabs;
- using std::lldiv;
-#endif
-
- using std::atoll;
- using std::strtoll;
- using std::strtoull;
-
- using std::strtof;
- using std::strtold;
-
- // overloads
- using std::abs;
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
- using std::div;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
#endif
-#endif
-
-_GLIBCXX_END_NAMESPACE
-}
+#include <cstdlib>
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cstdlib>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cstdlib>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CSTDLIB
// TR1 ctgmath -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CTGMATH
-#define _TR1_CTGMATH 1
+#ifndef _GLIBCXX_TR1_CTGMATH
+#define _GLIBCXX_TR1_CTGMATH 1
#include <tr1/cmath>
-#endif
+#endif // _GLIBCXX_TR1_CTGMATH
// TR1 ctime -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CTIME
-#define _TR1_CTIME 1
+#ifndef _GLIBCXX_TR1_CTIME
+#define _GLIBCXX_TR1_CTIME 1
#include <ctime>
-#endif
+#endif // _GLIBCXX_TR1_CTIME
// TR1 cwchar -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CWCHAR
-#define _TR1_CWCHAR 1
+#ifndef _GLIBCXX_TR1_CWCHAR
+#define _GLIBCXX_TR1_CWCHAR 1
-#include <bits/c++config.h>
+#pragma GCC system_header
-#if _GLIBCXX_USE_WCHAR_T
-
-#include <cwchar>
-
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_HAVE_WCSTOF
- using std::wcstof;
-#endif
-#if _GLIBCXX_HAVE_VFWSCANF
- using std::vfwscanf;
-#endif
-#if _GLIBCXX_HAVE_VSWSCANF
- using std::vswscanf;
-#endif
-#if _GLIBCXX_HAVE_VWSCANF
- using std::vwscanf;
-#endif
-
-#if _GLIBCXX_USE_C99
- using std::wcstold;
- using std::wcstoll;
- using std::wcstoull;
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
#endif
-_GLIBCXX_END_NAMESPACE
-}
+#include <cwchar>
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cwchar>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cwchar>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CWCHAR
// TR1 cwctype -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_CWCTYPE
-#define _TR1_CWCTYPE 1
+#ifndef _GLIBCXX_TR1_CWCTYPE
+#define _GLIBCXX_TR1_CWCTYPE 1
-#include <bits/c++config.h>
+#pragma GCC system_header
-#if _GLIBCXX_USE_WCHAR_T
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
#include <cwctype>
-// namespace std::tr1
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-#if _GLIBCXX_HAVE_ISWBLANK
- using std::iswblank;
-#endif
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/cwctype>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/cwctype>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-#endif
+#endif // _GLIBCXX_TR1_CWCTYPE
// W. T. Vetterling, B. P. Flannery, Cambridge University Press
// (1992), pp. 261-269
-#ifndef _TR1_ELL_INTEGRAL_TCC
-#define _TR1_ELL_INTEGRAL_TCC 1
+#ifndef _GLIBCXX_TR1_ELL_INTEGRAL_TCC
+#define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_ELL_INTEGRAL_TCC
+#endif // _GLIBCXX_TR1_ELL_INTEGRAL_TCC
// 2nd ed, pp. 222-225.
//
-#ifndef _TR1_EXP_INTEGRAL_TCC
-#define _TR1_EXP_INTEGRAL_TCC 1
+#ifndef _GLIBCXX_TR1_EXP_INTEGRAL_TCC
+#define _GLIBCXX_TR1_EXP_INTEGRAL_TCC 1
#include "special_function_util.h"
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_EXP_INTEGRAL_TCC
+#endif // _GLIBCXX_TR1_EXP_INTEGRAL_TCC
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_FUNCTIONAL
-#define _TR1_FUNCTIONAL 1
+#ifndef _GLIBCXX_TR1_FUNCTIONAL
+#define _GLIBCXX_TR1_FUNCTIONAL 1
#pragma GCC system_header
-#include <cmath> // for std::frexp
-#include <string> // for std::tr1::hash
-#include <functional>
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
+
+#include <bits/c++config.h>
+#include <bits/stl_function.h>
+
+#include <cmath>
+#include <string>
#include <typeinfo>
+#include <ext/type_traits.h>
#include <tr1/tuple>
#include <tr1/type_traits>
-#include <ext/type_traits.h>
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- template<typename _MemberPointer>
- class _Mem_fn;
-
- /**
- * @if maint
- * Actual implementation of _Has_result_type, which uses SFINAE to
- * determine if the type _Tp has a publicly-accessible member type
- * result_type.
- * @endif
- */
- template<typename _Tp>
- class _Has_result_type_helper : __sfinae_types
- {
- template<typename _Up>
- struct _Wrap_type
- { };
-
- template<typename _Up>
- static __one __test(_Wrap_type<typename _Up::result_type>*);
-
- template<typename _Up>
- static __two __test(...);
-
- public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
- };
-
- template<typename _Tp>
- struct _Has_result_type
- : integral_constant<bool,
- _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
- { };
-
- /**
- * @if maint
- * If we have found a result_type, extract it.
- * @endif
- */
- template<bool _Has_result_type, typename _Functor>
- struct _Maybe_get_result_type
- { };
-
- template<typename _Functor>
- struct _Maybe_get_result_type<true, _Functor>
- {
- typedef typename _Functor::result_type result_type;
- };
-
- /**
- * @if maint
- * Base class for any function object that has a weak result type, as
- * defined in 3.3/3 of TR1.
- * @endif
- */
- template<typename _Functor>
- struct _Weak_result_type_impl
- : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
- {
- };
-
- /**
- * @if maint
- * Retrieve the result type for a function type.
- * @endif
- */
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes...)>
- {
- typedef _Res result_type;
- };
-
- /**
- * @if maint
- * Retrieve the result type for a function reference.
- * @endif
- */
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
- {
- typedef _Res result_type;
- };
-
- /**
- * @if maint
- * Retrieve the result type for a function pointer.
- * @endif
- */
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
- {
- typedef _Res result_type;
- };
-
- /**
- * @if maint
- * Retrieve result type for a member function pointer.
- * @endif maint
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
- {
- typedef _Res result_type;
- };
-
- /**
- * @if maint
- * Retrieve result type for a const member function pointer.
- * @endif maint
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
- {
- typedef _Res result_type;
- };
-
- /**
- * @if maint
- * Retrieve result type for a volatile member function pointer.
- * @endif maint
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
- {
- typedef _Res result_type;
- };
-
- /**
- * @if maint
- * Retrieve result type for a const volatile member function pointer.
- * @endif maint
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile>
- {
- typedef _Res result_type;
- };
-
- /**
- * @if maint
- * Strip top-level cv-qualifiers from the function object and let
- * _Weak_result_type_impl perform the real work.
- * @endif
- */
- template<typename _Functor>
- struct _Weak_result_type
- : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
- {
- };
-
- template<typename _Signature>
- class result_of;
-
- /**
- * @if maint
- * Actual implementation of result_of. When _Has_result_type is
- * true, gets its result from _Weak_result_type. Otherwise, uses
- * the function object's member template result to extract the
- * result type.
- * @endif
- */
- template<bool _Has_result_type, typename _Signature>
- struct _Result_of_impl;
-
- // Handle member data pointers using _Mem_fn's logic
- template<typename _Res, typename _Class, typename _T1>
- struct _Result_of_impl<false, _Res _Class::*(_T1)>
- {
- typedef typename _Mem_fn<_Res _Class::*>
- ::template _Result_type<_T1>::type type;
- };
-
- /**
- * @if maint
- * Determine whether we can determine a result type from @c Functor
- * alone.
- * @endif
- */
- template<typename _Functor, typename... _ArgTypes>
- class result_of<_Functor(_ArgTypes...)>
- : public _Result_of_impl<
- _Has_result_type<_Weak_result_type<_Functor> >::value,
- _Functor(_ArgTypes...)>
- {
- };
-
- /**
- * @if maint
- * We already know the result type for @c Functor; use it.
- * @endif
- */
- template<typename _Functor, typename... _ArgTypes>
- struct _Result_of_impl<true, _Functor(_ArgTypes...)>
- {
- typedef typename _Weak_result_type<_Functor>::result_type type;
- };
-
- /**
- * @if maint
- * We need to compute the result type for this invocation the hard
- * way.
- * @endif
- */
- template<typename _Functor, typename... _ArgTypes>
- struct _Result_of_impl<false, _Functor(_ArgTypes...)>
- {
- typedef typename _Functor
- ::template result<_Functor(_ArgTypes...)>::type type;
- };
-
- /**
- * @if maint
- * It is unsafe to access ::result when there are zero arguments, so we
- * return @c void instead.
- * @endif
- */
- template<typename _Functor>
- struct _Result_of_impl<false, _Functor()>
- {
- typedef void type;
- };
-
- /**
- * @if maint
- * Determines if the type _Tp derives from unary_function.
- * @endif
- */
- template<typename _Tp>
- struct _Derives_from_unary_function : __sfinae_types
- {
- private:
- template<typename _T1, typename _Res>
- static __one __test(const volatile unary_function<_T1, _Res>*);
-
- // It's tempting to change "..." to const volatile void*, but
- // that fails when _Tp is a function type.
- static __two __test(...);
-
- public:
- static const bool value = sizeof(__test((_Tp*)0)) == 1;
- };
-
- /**
- * @if maint
- * Determines if the type _Tp derives from binary_function.
- * @endif
- */
- template<typename _Tp>
- struct _Derives_from_binary_function : __sfinae_types
- {
- private:
- template<typename _T1, typename _T2, typename _Res>
- static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
-
- // It's tempting to change "..." to const volatile void*, but
- // that fails when _Tp is a function type.
- static __two __test(...);
-
- public:
- static const bool value = sizeof(__test((_Tp*)0)) == 1;
- };
-
- /**
- * @if maint
- * Turns a function type into a function pointer type
- * @endif
- */
- template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
- struct _Function_to_function_pointer
- {
- typedef _Tp type;
- };
-
- template<typename _Tp>
- struct _Function_to_function_pointer<_Tp, true>
- {
- typedef _Tp* type;
- };
-
- /**
- * @if maint
- * Invoke a function object, which may be either a member pointer or a
- * function object. The first parameter will tell which.
- * @endif
- */
- template<typename _Functor, typename... _Args>
- inline
- typename __gnu_cxx::__enable_if<
- (!is_member_pointer<_Functor>::value
- && !is_function<_Functor>::value
- && !is_function<typename remove_pointer<_Functor>::type>::value),
- typename result_of<_Functor(_Args...)>::type
- >::__type
- __invoke(_Functor& __f, _Args&... __args)
- {
- return __f(__args...);
- }
-
- template<typename _Functor, typename... _Args>
- inline
- typename __gnu_cxx::__enable_if<
- (is_member_pointer<_Functor>::value
- && !is_function<_Functor>::value
- && !is_function<typename remove_pointer<_Functor>::type>::value),
- typename result_of<_Functor(_Args...)>::type
- >::__type
- __invoke(_Functor& __f, _Args&... __args)
- {
- return mem_fn(__f)(__args...);
- }
-
- // To pick up function references (that will become function pointers)
- template<typename _Functor, typename... _Args>
- inline
- typename __gnu_cxx::__enable_if<
- (is_pointer<_Functor>::value
- && is_function<typename remove_pointer<_Functor>::type>::value),
- typename result_of<_Functor(_Args...)>::type
- >::__type
- __invoke(_Functor __f, _Args&... __args)
- {
- return __f(__args...);
- }
-
- /**
- * @if maint
- * Knowing which of unary_function and binary_function _Tp derives
- * from, derives from the same and ensures that reference_wrapper
- * will have a weak result type. See cases below.
- * @endif
- */
- template<bool _Unary, bool _Binary, typename _Tp>
- struct _Reference_wrapper_base_impl;
-
- // Not a unary_function or binary_function, so try a weak result type
- template<typename _Tp>
- struct _Reference_wrapper_base_impl<false, false, _Tp>
- : _Weak_result_type<_Tp>
- { };
-
- // unary_function but not binary_function
- template<typename _Tp>
- struct _Reference_wrapper_base_impl<true, false, _Tp>
- : unary_function<typename _Tp::argument_type,
- typename _Tp::result_type>
- { };
-
- // binary_function but not unary_function
- template<typename _Tp>
- struct _Reference_wrapper_base_impl<false, true, _Tp>
- : binary_function<typename _Tp::first_argument_type,
- typename _Tp::second_argument_type,
- typename _Tp::result_type>
- { };
-
- // both unary_function and binary_function. import result_type to
- // avoid conflicts.
- template<typename _Tp>
- struct _Reference_wrapper_base_impl<true, true, _Tp>
- : unary_function<typename _Tp::argument_type,
- typename _Tp::result_type>,
- binary_function<typename _Tp::first_argument_type,
- typename _Tp::second_argument_type,
- typename _Tp::result_type>
- {
- typedef typename _Tp::result_type result_type;
- };
-
- /**
- * @if maint
- * Derives from unary_function or binary_function when it
- * can. Specializations handle all of the easy cases. The primary
- * template determines what to do with a class type, which may
- * derive from both unary_function and binary_function.
- * @endif
- */
- template<typename _Tp>
- struct _Reference_wrapper_base
- : _Reference_wrapper_base_impl<
- _Derives_from_unary_function<_Tp>::value,
- _Derives_from_binary_function<_Tp>::value,
- _Tp>
- { };
-
- // - a function type (unary)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res(_T1)>
- : unary_function<_T1, _Res>
- { };
-
- // - a function type (binary)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res(_T1, _T2)>
- : binary_function<_T1, _T2, _Res>
- { };
-
- // - a function pointer type (unary)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res(*)(_T1)>
- : unary_function<_T1, _Res>
- { };
-
- // - a function pointer type (binary)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
- : binary_function<_T1, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, no qualifiers)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)()>
- : unary_function<_T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, no qualifiers)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
- : binary_function<_T1*, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, const)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)() const>
- : unary_function<const _T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, const)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
- : binary_function<const _T1*, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, volatile)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
- : unary_function<volatile _T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, volatile)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
- : binary_function<volatile _T1*, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, const volatile)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
- : unary_function<const volatile _T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, const volatile)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
- : binary_function<const volatile _T1*, _T2, _Res>
- { };
-
- template<typename _Tp>
- class reference_wrapper
- : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
- {
- // If _Tp is a function type, we can't form result_of<_Tp(...)>,
- // so turn it into a function pointer type.
- typedef typename _Function_to_function_pointer<_Tp>::type
- _M_func_type;
-
- _Tp* _M_data;
- public:
- typedef _Tp type;
-
- explicit
- reference_wrapper(_Tp& __indata): _M_data(&__indata)
- { }
-
- reference_wrapper(const reference_wrapper<_Tp>& __inref):
- _M_data(__inref._M_data)
- { }
-
- reference_wrapper&
- operator=(const reference_wrapper<_Tp>& __inref)
- {
- _M_data = __inref._M_data;
- return *this;
- }
-
- operator _Tp&() const
- { return this->get(); }
-
- _Tp&
- get() const
- { return *_M_data; }
-
- template<typename... _Args>
- typename result_of<_M_func_type(_Args...)>::type
- operator()(_Args&... __args) const
- {
- return __invoke(get(), __args...);
- }
- };
-
-
- // Denotes a reference should be taken to a variable.
- template<typename _Tp>
- inline reference_wrapper<_Tp>
- ref(_Tp& __t)
- { return reference_wrapper<_Tp>(__t); }
-
- // Denotes a const reference should be taken to a variable.
- template<typename _Tp>
- inline reference_wrapper<const _Tp>
- cref(const _Tp& __t)
- { return reference_wrapper<const _Tp>(__t); }
-
- template<typename _Tp>
- inline reference_wrapper<_Tp>
- ref(reference_wrapper<_Tp> __t)
- { return ref(__t.get()); }
-
- template<typename _Tp>
- inline reference_wrapper<const _Tp>
- cref(reference_wrapper<_Tp> __t)
- { return cref(__t.get()); }
-
- template<typename _Tp, bool>
- struct _Mem_fn_const_or_non
- {
- typedef const _Tp& type;
- };
-
- template<typename _Tp>
- struct _Mem_fn_const_or_non<_Tp, false>
- {
- typedef _Tp& type;
- };
-
- /**
- * @if maint
- * Derives from @c unary_function or @c binary_function, or perhaps
- * nothing, depending on the number of arguments provided. The
- * primary template is the basis case, which derives nothing.
- * @endif maint
- */
- template<typename _Res, typename... _ArgTypes>
- struct _Maybe_unary_or_binary_function { };
-
- /**
- * @if maint
- * Derives from @c unary_function, as appropriate.
- * @endif
- */
- template<typename _Res, typename _T1>
- struct _Maybe_unary_or_binary_function<_Res, _T1>
- : std::unary_function<_T1, _Res> { };
-
- /**
- * @if maint
- * Derives from @c binary_function, as appropriate.
- * @endif
- */
- template<typename _Res, typename _T1, typename _T2>
- struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
- : std::binary_function<_T1, _T2, _Res> { };
-
- /**
- * @if maint
- * Implementation of @c mem_fn for member function pointers.
- * @endif
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
- : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
- {
- typedef _Res (_Class::*_Functor)(_ArgTypes...);
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(__args...); }
-
- public:
- typedef _Res result_type;
-
- explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
- // Handle objects
- _Res
- operator()(_Class& __object, _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- // Handle pointers
- _Res
- operator()(_Class* __object, _ArgTypes... __args) const
- { return (__object->*__pmf)(__args...); }
-
- // Handle smart pointers, references and pointers to derived
- template<typename _Tp>
- _Res
- operator()(_Tp& __object, _ArgTypes... __args) const
- { return _M_call(__object, &__object, __args...); }
-
- private:
- _Functor __pmf;
- };
-
- /**
- * @if maint
- * Implementation of @c mem_fn for const member function pointers.
- * @endif
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
- : public _Maybe_unary_or_binary_function<_Res, const _Class*,
- _ArgTypes...>
- {
- typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(__args...); }
-
- public:
- typedef _Res result_type;
-
- explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
- // Handle objects
- _Res
- operator()(const _Class& __object, _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- // Handle pointers
- _Res
- operator()(const _Class* __object, _ArgTypes... __args) const
- { return (__object->*__pmf)(__args...); }
-
- // Handle smart pointers, references and pointers to derived
- template<typename _Tp>
- _Res operator()(_Tp& __object, _ArgTypes... __args) const
- { return _M_call(__object, &__object, __args...); }
-
- private:
- _Functor __pmf;
- };
-
- /**
- * @if maint
- * Implementation of @c mem_fn for volatile member function pointers.
- * @endif
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
- : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
- _ArgTypes...>
- {
- typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(__args...); }
-
- public:
- typedef _Res result_type;
-
- explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
- // Handle objects
- _Res
- operator()(volatile _Class& __object, _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- // Handle pointers
- _Res
- operator()(volatile _Class* __object, _ArgTypes... __args) const
- { return (__object->*__pmf)(__args...); }
-
- // Handle smart pointers, references and pointers to derived
- template<typename _Tp>
- _Res
- operator()(_Tp& __object, _ArgTypes... __args) const
- { return _M_call(__object, &__object, __args...); }
-
- private:
- _Functor __pmf;
- };
-
- /**
- * @if maint
- * Implementation of @c mem_fn for const volatile member function pointers.
- * @endif
- */
- template<typename _Res, typename _Class, typename... _ArgTypes>
- class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
- : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
- _ArgTypes...>
- {
- typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(__args...); }
-
- public:
- typedef _Res result_type;
-
- explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
-
- // Handle objects
- _Res
- operator()(const volatile _Class& __object, _ArgTypes... __args) const
- { return (__object.*__pmf)(__args...); }
-
- // Handle pointers
- _Res
- operator()(const volatile _Class* __object, _ArgTypes... __args) const
- { return (__object->*__pmf)(__args...); }
-
- // Handle smart pointers, references and pointers to derived
- template<typename _Tp>
- _Res operator()(_Tp& __object, _ArgTypes... __args) const
- { return _M_call(__object, &__object, __args...); }
-
- private:
- _Functor __pmf;
- };
-
-
- template<typename _Res, typename _Class>
- class _Mem_fn<_Res _Class::*>
- {
- // This bit of genius is due to Peter Dimov, improved slightly by
- // Douglas Gregor.
- template<typename _Tp>
- _Res&
- _M_call(_Tp& __object, _Class *) const
- { return __object.*__pm; }
-
- template<typename _Tp, typename _Up>
- _Res&
- _M_call(_Tp& __object, _Up * const *) const
- { return (*__object).*__pm; }
-
- template<typename _Tp, typename _Up>
- const _Res&
- _M_call(_Tp& __object, const _Up * const *) const
- { return (*__object).*__pm; }
-
- template<typename _Tp>
- const _Res&
- _M_call(_Tp& __object, const _Class *) const
- { return __object.*__pm; }
-
- template<typename _Tp>
- const _Res&
- _M_call(_Tp& __ptr, const volatile void*) const
- { return (*__ptr).*__pm; }
-
- template<typename _Tp> static _Tp& __get_ref();
-
- template<typename _Tp>
- static __sfinae_types::__one __check_const(_Tp&, _Class*);
- template<typename _Tp, typename _Up>
- static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
- template<typename _Tp, typename _Up>
- static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
- template<typename _Tp>
- static __sfinae_types::__two __check_const(_Tp&, const _Class*);
- template<typename _Tp>
- static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
-
- public:
- template<typename _Tp>
- struct _Result_type
- : _Mem_fn_const_or_non<_Res,
- (sizeof(__sfinae_types::__two)
- == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
- { };
-
- template<typename _Signature>
- struct result;
-
- template<typename _CVMem, typename _Tp>
- struct result<_CVMem(_Tp)>
- : public _Result_type<_Tp> { };
-
- template<typename _CVMem, typename _Tp>
- struct result<_CVMem(_Tp&)>
- : public _Result_type<_Tp> { };
-
- explicit
- _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
-
- // Handle objects
- _Res&
- operator()(_Class& __object) const
- { return __object.*__pm; }
-
- const _Res&
- operator()(const _Class& __object) const
- { return __object.*__pm; }
-
- // Handle pointers
- _Res&
- operator()(_Class* __object) const
- { return __object->*__pm; }
-
- const _Res&
- operator()(const _Class* __object) const
- { return __object->*__pm; }
-
- // Handle smart pointers and derived
- template<typename _Tp>
- typename _Result_type<_Tp>::type
- operator()(_Tp& __unknown) const
- { return _M_call(__unknown, &__unknown); }
-
- private:
- _Res _Class::*__pm;
- };
-
- /**
- * @brief Returns a function object that forwards to the member
- * pointer @a pm.
- */
- template<typename _Tp, typename _Class>
- inline _Mem_fn<_Tp _Class::*>
- mem_fn(_Tp _Class::* __pm)
- {
- return _Mem_fn<_Tp _Class::*>(__pm);
- }
-
- /**
- * @brief Determines if the given type _Tp is a function object
- * should be treated as a subexpression when evaluating calls to
- * function objects returned by bind(). [TR1 3.6.1]
- */
- template<typename _Tp>
- struct is_bind_expression
- { static const bool value = false; };
-
- template<typename _Tp>
- const bool is_bind_expression<_Tp>::value;
-
- /**
- * @brief Determines if the given type _Tp is a placeholder in a
- * bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
- */
- template<typename _Tp>
- struct is_placeholder
- { static const int value = 0; };
-
- template<typename _Tp>
- const int is_placeholder<_Tp>::value;
-
- /**
- * @if maint
- * The type of placeholder objects defined by libstdc++.
- * @endif
- */
- template<int _Num> struct _Placeholder { };
-
- // Define a large number of placeholders. There is no way to
- // simplify this with variadic templates, because we're introducing
- // unique names for each.
- namespace placeholders { namespace {
- _Placeholder<1> _1;
- _Placeholder<2> _2;
- _Placeholder<3> _3;
- _Placeholder<4> _4;
- _Placeholder<5> _5;
- _Placeholder<6> _6;
- _Placeholder<7> _7;
- _Placeholder<8> _8;
- _Placeholder<9> _9;
- _Placeholder<10> _10;
- _Placeholder<11> _11;
- _Placeholder<12> _12;
- _Placeholder<13> _13;
- _Placeholder<14> _14;
- _Placeholder<15> _15;
- _Placeholder<16> _16;
- _Placeholder<17> _17;
- _Placeholder<18> _18;
- _Placeholder<19> _19;
- _Placeholder<20> _20;
- _Placeholder<21> _21;
- _Placeholder<22> _22;
- _Placeholder<23> _23;
- _Placeholder<24> _24;
- _Placeholder<25> _25;
- _Placeholder<26> _26;
- _Placeholder<27> _27;
- _Placeholder<28> _28;
- _Placeholder<29> _29;
- } }
-
- /**
- * @if maint
- * Partial specialization of is_placeholder that provides the placeholder
- * number for the placeholder objects defined by libstdc++.
- * @endif
- */
- template<int _Num>
- struct is_placeholder<_Placeholder<_Num> >
- { static const int value = _Num; };
-
- template<int _Num>
- const int is_placeholder<_Placeholder<_Num> >::value;
-
- /**
- * @if maint
- * Stores a tuple of indices. Used by bind() to extract the elements
- * in a tuple.
- * @endif
- */
- template<int... _Indexes>
- struct _Index_tuple { };
-
- /**
- * @if maint
- * Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
- * @endif
- */
- template<std::size_t _Num, typename _Tuple = _Index_tuple<> >
- struct _Build_index_tuple;
-
- template<std::size_t _Num, int... _Indexes>
- struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
- : _Build_index_tuple<_Num - 1,
- _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
- {
- };
-
- template<int... _Indexes>
- struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
- {
- typedef _Index_tuple<_Indexes...> __type;
- };
-
- /**
- * @if maint
- * Used by _Safe_tuple_element to indicate that there is no tuple
- * element at this position.
- * @endif
- */
- struct _No_tuple_element;
-
- /**
- * @if maint
- * Implementation helper for _Safe_tuple_element. This primary
- * template handles the case where it is safe to use @c
- * tuple_element.
- * @endif
- */
- template<int __i, typename _Tuple, bool _IsSafe>
- struct _Safe_tuple_element_impl
- : tuple_element<__i, _Tuple> { };
-
- /**
- * @if maint
- * Implementation helper for _Safe_tuple_element. This partial
- * specialization handles the case where it is not safe to use @c
- * tuple_element. We just return @c _No_tuple_element.
- * @endif
- */
- template<int __i, typename _Tuple>
- struct _Safe_tuple_element_impl<__i, _Tuple, false>
- {
- typedef _No_tuple_element type;
- };
-
- /**
- * Like tuple_element, but returns @c _No_tuple_element when
- * tuple_element would return an error.
- */
- template<int __i, typename _Tuple>
- struct _Safe_tuple_element
- : _Safe_tuple_element_impl<__i, _Tuple,
- (__i >= 0 && __i < tuple_size<_Tuple>::value)>
- {
- };
-
- /**
- * @if maint
- * Maps an argument to bind() into an actual argument to the bound
- * function object [TR1 3.6.3/5]. Only the first parameter should
- * be specified: the rest are used to determine among the various
- * implementations. Note that, although this class is a function
- * object, isn't not entirely normal because it takes only two
- * parameters regardless of the number of parameters passed to the
- * bind expression. The first parameter is the bound argument and
- * the second parameter is a tuple containing references to the
- * rest of the arguments.
- * @endif
- */
- template<typename _Arg,
- bool _IsBindExp = is_bind_expression<_Arg>::value,
- bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
- class _Mu;
-
- /**
- * @if maint
- * If the argument is reference_wrapper<_Tp>, returns the
- * underlying reference. [TR1 3.6.3/5 bullet 1]
- * @endif
- */
- template<typename _Tp>
- class _Mu<reference_wrapper<_Tp>, false, false>
- {
- public:
- typedef _Tp& result_type;
-
- /* Note: This won't actually work for const volatile
- * reference_wrappers, because reference_wrapper::get() is const
- * but not volatile-qualified. This might be a defect in the TR.
- */
- template<typename _CVRef, typename _Tuple>
- result_type
- operator()(_CVRef& __arg, const _Tuple&) const volatile
- { return __arg.get(); }
- };
-
- /**
- * @if maint
- * If the argument is a bind expression, we invoke the underlying
- * function object with the same cv-qualifiers as we are given and
- * pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
- * @endif
- */
- template<typename _Arg>
- class _Mu<_Arg, true, false>
- {
- public:
- template<typename _Signature> class result;
-
- // Determine the result type when we pass the arguments along. This
- // involves passing along the cv-qualifiers placed on _Mu and
- // unwrapping the argument bundle.
- template<typename _CVMu, typename _CVArg, typename... _Args>
- class result<_CVMu(_CVArg, tuple<_Args...>)>
- : public result_of<_CVArg(_Args...)> { };
-
- template<typename _CVArg, typename... _Args>
- typename result_of<_CVArg(_Args...)>::type
- operator()(_CVArg& __arg,
- const tuple<_Args...>& __tuple) const volatile
- {
- // Construct an index tuple and forward to __call
- typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
- _Indexes;
- return this->__call(__arg, __tuple, _Indexes());
- }
-
- private:
- // Invokes the underlying function object __arg by unpacking all
- // of the arguments in the tuple.
- template<typename _CVArg, typename... _Args, int... _Indexes>
- typename result_of<_CVArg(_Args...)>::type
- __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
- const _Index_tuple<_Indexes...>&) const volatile
- {
- return __arg(_GLIBCXX_TR1::get<_Indexes>(__tuple)...);
- }
- };
-
- /**
- * @if maint
- * If the argument is a placeholder for the Nth argument, returns
- * a reference to the Nth argument to the bind function object.
- * [TR1 3.6.3/5 bullet 3]
- * @endif
- */
- template<typename _Arg>
- class _Mu<_Arg, false, true>
- {
- public:
- template<typename _Signature> class result;
-
- template<typename _CVMu, typename _CVArg, typename _Tuple>
- class result<_CVMu(_CVArg, _Tuple)>
- {
- // Add a reference, if it hasn't already been done for us.
- // This allows us to be a little bit sloppy in constructing
- // the tuple that we pass to result_of<...>.
- typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
- - 1), _Tuple>::type
- __base_type;
-
- public:
- typedef typename add_reference<__base_type>::type type;
- };
-
- template<typename _Tuple>
- typename result<_Mu(_Arg, _Tuple)>::type
- operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
- {
- return ::std::_GLIBCXX_TR1::get<(is_placeholder<_Arg>::value
- - 1)>(__tuple);
- }
- };
-
- /**
- * @if maint
- * If the argument is just a value, returns a reference to that
- * value. The cv-qualifiers on the reference are the same as the
- * cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
- * @endif
- */
- template<typename _Arg>
- class _Mu<_Arg, false, false>
- {
- public:
- template<typename _Signature> struct result;
-
- template<typename _CVMu, typename _CVArg, typename _Tuple>
- struct result<_CVMu(_CVArg, _Tuple)>
- {
- typedef typename add_reference<_CVArg>::type type;
- };
-
- // Pick up the cv-qualifiers of the argument
- template<typename _CVArg, typename _Tuple>
- _CVArg&
- operator()(_CVArg& __arg, const _Tuple&) const volatile
- { return __arg; }
- };
-
- /**
- * @if maint
- * Maps member pointers into instances of _Mem_fn but leaves all
- * other function objects untouched. Used by tr1::bind(). The
- * primary template handles the non--member-pointer case.
- * @endif
- */
- template<typename _Tp>
- struct _Maybe_wrap_member_pointer
- {
- typedef _Tp type;
-
- static const _Tp&
- __do_wrap(const _Tp& __x)
- { return __x; }
- };
-
- /**
- * @if maint
- * Maps member pointers into instances of _Mem_fn but leaves all
- * other function objects untouched. Used by tr1::bind(). This
- * partial specialization handles the member pointer case.
- * @endif
- */
- template<typename _Tp, typename _Class>
- struct _Maybe_wrap_member_pointer<_Tp _Class::*>
- {
- typedef _Mem_fn<_Tp _Class::*> type;
-
- static type
- __do_wrap(_Tp _Class::* __pm)
- { return type(__pm); }
- };
-
- /**
- * @if maint
- * Type of the function object returned from bind().
- * @endif
- */
- template<typename _Signature>
- struct _Bind;
-
- template<typename _Functor, typename... _Bound_args>
- class _Bind<_Functor(_Bound_args...)>
- : public _Weak_result_type<_Functor>
- {
- typedef _Bind __self_type;
- typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
- _Bound_indexes;
-
- _Functor _M_f;
- tuple<_Bound_args...> _M_bound_args;
-
- // Call unqualified
- template<typename... _Args, int... _Indexes>
- typename result_of<
- _Functor(typename result_of<_Mu<_Bound_args>
- (_Bound_args, tuple<_Args...>)>::type...)
- >::type
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- // Call as const
- template<typename... _Args, int... _Indexes>
- typename result_of<
- const _Functor(typename result_of<_Mu<_Bound_args>
- (const _Bound_args, tuple<_Args...>)
- >::type...)>::type
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- // Call as volatile
- template<typename... _Args, int... _Indexes>
- typename result_of<
- volatile _Functor(typename result_of<_Mu<_Bound_args>
- (volatile _Bound_args, tuple<_Args...>)
- >::type...)>::type
- __call(const tuple<_Args...>& __args,
- _Index_tuple<_Indexes...>) volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- // Call as const volatile
- template<typename... _Args, int... _Indexes>
- typename result_of<
- const volatile _Functor(typename result_of<_Mu<_Bound_args>
- (const volatile _Bound_args,
- tuple<_Args...>)
- >::type...)>::type
- __call(const tuple<_Args...>& __args,
- _Index_tuple<_Indexes...>) const volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- public:
- explicit _Bind(_Functor __f, _Bound_args... __bound_args)
- : _M_f(__f), _M_bound_args(__bound_args...) { }
-
- // Call unqualified
- template<typename... _Args>
- typename result_of<
- _Functor(typename result_of<_Mu<_Bound_args>
- (_Bound_args, tuple<_Args...>)>::type...)
- >::type
- operator()(_Args&... __args)
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
-
- // Call as const
- template<typename... _Args>
- typename result_of<
- const _Functor(typename result_of<_Mu<_Bound_args>
- (const _Bound_args, tuple<_Args...>)>::type...)
- >::type
- operator()(_Args&... __args) const
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
-
-
- // Call as volatile
- template<typename... _Args>
- typename result_of<
- volatile _Functor(typename result_of<_Mu<_Bound_args>
- (volatile _Bound_args, tuple<_Args...>)>::type...)
- >::type
- operator()(_Args&... __args) volatile
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
-
-
- // Call as const volatile
- template<typename... _Args>
- typename result_of<
- const volatile _Functor(typename result_of<_Mu<_Bound_args>
- (const volatile _Bound_args,
- tuple<_Args...>)>::type...)
- >::type
- operator()(_Args&... __args) const volatile
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
- };
-
- /**
- * @if maint
- * Type of the function object returned from bind<R>().
- * @endif
- */
- template<typename _Result, typename _Signature>
- struct _Bind_result;
-
- template<typename _Result, typename _Functor, typename... _Bound_args>
- class _Bind_result<_Result, _Functor(_Bound_args...)>
- {
- typedef _Bind_result __self_type;
- typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
- _Bound_indexes;
-
- _Functor _M_f;
- tuple<_Bound_args...> _M_bound_args;
-
- // Call unqualified
- template<typename... _Args, int... _Indexes>
- _Result
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- // Call as const
- template<typename... _Args, int... _Indexes>
- _Result
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- // Call as volatile
- template<typename... _Args, int... _Indexes>
- _Result
- __call(const tuple<_Args...>& __args,
- _Index_tuple<_Indexes...>) volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- // Call as const volatile
- template<typename... _Args, int... _Indexes>
- _Result
- __call(const tuple<_Args...>& __args,
- _Index_tuple<_Indexes...>) const volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (_GLIBCXX_TR1::get<_Indexes>(_M_bound_args), __args)...);
- }
-
- public:
- typedef _Result result_type;
-
- explicit
- _Bind_result(_Functor __f, _Bound_args... __bound_args)
- : _M_f(__f), _M_bound_args(__bound_args...) { }
-
- // Call unqualified
- template<typename... _Args>
- result_type
- operator()(_Args&... __args)
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
-
- // Call as const
- template<typename... _Args>
- result_type
- operator()(_Args&... __args) const
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
-
- // Call as volatile
- template<typename... _Args>
- result_type
- operator()(_Args&... __args) volatile
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
-
- // Call as const volatile
- template<typename... _Args>
- result_type
- operator()(_Args&... __args) const volatile
- {
- return this->__call(_GLIBCXX_TR1::tie(__args...), _Bound_indexes());
- }
- };
-
- /**
- * @if maint
- * Class template _Bind is always a bind expression.
- * @endif
- */
- template<typename _Signature>
- struct is_bind_expression<_Bind<_Signature> >
- { static const bool value = true; };
-
- template<typename _Signature>
- const bool is_bind_expression<_Bind<_Signature> >::value;
-
- /**
- * @if maint
- * Class template _Bind_result is always a bind expression.
- * @endif
- */
- template<typename _Result, typename _Signature>
- struct is_bind_expression<_Bind_result<_Result, _Signature> >
- { static const bool value = true; };
-
- template<typename _Result, typename _Signature>
- const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value;
-
- template<typename _Functor, typename... _ArgTypes>
- inline
- _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)>
- bind(_Functor __f, _ArgTypes... __args)
- {
- typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
- typedef typename __maybe_type::type __functor_type;
- typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
- return __result_type(__maybe_type::__do_wrap(__f), __args...);
- }
-
- template<typename _Result, typename _Functor, typename... _ArgTypes>
- inline
- _Bind_result<_Result,
- typename _Maybe_wrap_member_pointer<_Functor>::type
- (_ArgTypes...)>
- bind(_Functor __f, _ArgTypes... __args)
- {
- typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
- typedef typename __maybe_type::type __functor_type;
- typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
- __result_type;
- return __result_type(__maybe_type::__do_wrap(__f), __args...);
- }
-
- /**
- * @brief Exception class thrown when class template function's
- * operator() is called with an empty target.
- *
- */
- class bad_function_call : public std::exception { };
-
- /**
- * @if maint
- * The integral constant expression 0 can be converted into a
- * pointer to this type. It is used by the function template to
- * accept NULL pointers.
- * @endif
- */
- struct _M_clear_type;
-
- /**
- * @if maint
- * Trait identifying "location-invariant" types, meaning that the
- * address of the object (or any of its members) will not escape.
- * Also implies a trivial copy constructor and assignment operator.
- * @endif
- */
- template<typename _Tp>
- struct __is_location_invariant
- : integral_constant<bool,
- (is_pointer<_Tp>::value
- || is_member_pointer<_Tp>::value)>
- {
- };
-
- class _Undefined_class;
-
- union _Nocopy_types
- {
- void* _M_object;
- const void* _M_const_object;
- void (*_M_function_pointer)();
- void (_Undefined_class::*_M_member_pointer)();
- };
-
- union _Any_data
- {
- void* _M_access() { return &_M_pod_data[0]; }
- const void* _M_access() const { return &_M_pod_data[0]; }
-
- template<typename _Tp>
- _Tp&
- _M_access()
- { return *static_cast<_Tp*>(_M_access()); }
-
- template<typename _Tp>
- const _Tp&
- _M_access() const
- { return *static_cast<const _Tp*>(_M_access()); }
-
- _Nocopy_types _M_unused;
- char _M_pod_data[sizeof(_Nocopy_types)];
- };
-
- enum _Manager_operation
- {
- __get_type_info,
- __get_functor_ptr,
- __clone_functor,
- __destroy_functor
- };
-
- /* Simple type wrapper that helps avoid annoying const problems
- when casting between void pointers and pointers-to-pointers. */
- template<typename _Tp>
- struct _Simple_type_wrapper
- {
- _Simple_type_wrapper(_Tp __value) : __value(__value) { }
-
- _Tp __value;
- };
-
- template<typename _Tp>
- struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
- : __is_location_invariant<_Tp>
- {
- };
-
- // Converts a reference to a function object into a callable
- // function object.
- template<typename _Functor>
- inline _Functor&
- __callable_functor(_Functor& __f)
- { return __f; }
-
- template<typename _Member, typename _Class>
- inline _Mem_fn<_Member _Class::*>
- __callable_functor(_Member _Class::* &__p)
- { return mem_fn(__p); }
-
- template<typename _Member, typename _Class>
- inline _Mem_fn<_Member _Class::*>
- __callable_functor(_Member _Class::* const &__p)
- { return mem_fn(__p); }
-
- template<typename _Signature>
- class function;
-
- /**
- * @if maint
- * Base class of all polymorphic function object wrappers.
- * @endif
- */
- class _Function_base
- {
- public:
- static const std::size_t _M_max_size = sizeof(_Nocopy_types);
- static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
-
- template<typename _Functor>
- class _Base_manager
- {
- protected:
- static const bool __stored_locally =
- (__is_location_invariant<_Functor>::value
- && sizeof(_Functor) <= _M_max_size
- && __alignof__(_Functor) <= _M_max_align
- && (_M_max_align % __alignof__(_Functor) == 0));
-
- typedef integral_constant<bool, __stored_locally> _Local_storage;
-
- // Retrieve a pointer to the function object
- static _Functor*
- _M_get_pointer(const _Any_data& __source)
- {
- const _Functor* __ptr =
- __stored_locally? &__source._M_access<_Functor>()
- /* have stored a pointer */ : __source._M_access<_Functor*>();
- return const_cast<_Functor*>(__ptr);
- }
-
- // Clone a location-invariant function object that fits within
- // an _Any_data structure.
- static void
- _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
- {
- new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
- }
-
- // Clone a function object that is not location-invariant or
- // that cannot fit into an _Any_data structure.
- static void
- _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
- {
- __dest._M_access<_Functor*>() =
- new _Functor(*__source._M_access<_Functor*>());
- }
-
- // Destroying a location-invariant object may still require
- // destruction.
- static void
- _M_destroy(_Any_data& __victim, true_type)
- {
- __victim._M_access<_Functor>().~_Functor();
- }
-
- // Destroying an object located on the heap.
- static void
- _M_destroy(_Any_data& __victim, false_type)
- {
- delete __victim._M_access<_Functor*>();
- }
-
- public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
- _Manager_operation __op)
- {
- switch (__op)
- {
- case __get_type_info:
- __dest._M_access<const type_info*>() = &typeid(_Functor);
- break;
-
- case __get_functor_ptr:
- __dest._M_access<_Functor*>() = _M_get_pointer(__source);
- break;
-
- case __clone_functor:
- _M_clone(__dest, __source, _Local_storage());
- break;
-
- case __destroy_functor:
- _M_destroy(__dest, _Local_storage());
- break;
- }
- return false;
- }
-
- static void
- _M_init_functor(_Any_data& __functor, const _Functor& __f)
- {
- _M_init_functor(__functor, __f, _Local_storage());
- }
-
- template<typename _Signature>
- static bool
- _M_not_empty_function(const function<_Signature>& __f)
- {
- return __f;
- }
-
- template<typename _Tp>
- static bool
- _M_not_empty_function(const _Tp*& __fp)
- {
- return __fp;
- }
-
- template<typename _Class, typename _Tp>
- static bool
- _M_not_empty_function(_Tp _Class::* const& __mp)
- {
- return __mp;
- }
-
- template<typename _Tp>
- static bool
- _M_not_empty_function(const _Tp&)
- {
- return true;
- }
-
- private:
- static void
- _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
- {
- new (__functor._M_access()) _Functor(__f);
- }
-
- static void
- _M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
- {
- __functor._M_access<_Functor*>() = new _Functor(__f);
- }
- };
-
- template<typename _Functor>
- class _Ref_manager : public _Base_manager<_Functor*>
- {
- typedef _Function_base::_Base_manager<_Functor*> _Base;
-
- public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
- _Manager_operation __op)
- {
- switch (__op)
- {
- case __get_type_info:
- __dest._M_access<const type_info*>() = &typeid(_Functor);
- break;
-
- case __get_functor_ptr:
- __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
- return is_const<_Functor>::value;
- break;
-
- default:
- _Base::_M_manager(__dest, __source, __op);
- }
- return false;
- }
-
- static void
- _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
- {
- // TBD: Use address_of function instead
- _Base::_M_init_functor(__functor, &__f.get());
- }
- };
-
- _Function_base() : _M_manager(0) { }
-
- ~_Function_base()
- {
- if (_M_manager)
- _M_manager(_M_functor, _M_functor, __destroy_functor);
- }
-
-
- bool _M_empty() const { return !_M_manager; }
-
- typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
- _Manager_operation);
-
- _Any_data _M_functor;
- _Manager_type _M_manager;
- };
-
- template<typename _Signature, typename _Functor>
- class _Function_handler;
-
- template<typename _Res, typename _Functor, typename... _ArgTypes>
- class _Function_handler<_Res(_ArgTypes...), _Functor>
- : public _Function_base::_Base_manager<_Functor>
- {
- typedef _Function_base::_Base_manager<_Functor> _Base;
-
- public:
- static _Res
- _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
- {
- return (*_Base::_M_get_pointer(__functor))(__args...);
- }
- };
-
- template<typename _Functor, typename... _ArgTypes>
- class _Function_handler<void(_ArgTypes...), _Functor>
- : public _Function_base::_Base_manager<_Functor>
- {
- typedef _Function_base::_Base_manager<_Functor> _Base;
-
- public:
- static void
- _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
- {
- (*_Base::_M_get_pointer(__functor))(__args...);
- }
- };
-
- template<typename _Res, typename _Functor, typename... _ArgTypes>
- class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
- : public _Function_base::_Ref_manager<_Functor>
- {
- typedef _Function_base::_Ref_manager<_Functor> _Base;
-
- public:
- static _Res
- _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
- {
- return
- __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
- }
- };
-
- template<typename _Functor, typename... _ArgTypes>
- class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
- : public _Function_base::_Ref_manager<_Functor>
- {
- typedef _Function_base::_Ref_manager<_Functor> _Base;
-
- public:
- static void
- _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
- {
- __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
- }
- };
-
- template<typename _Class, typename _Member, typename _Res,
- typename... _ArgTypes>
- class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
- : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
- {
- typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
- _Base;
-
- public:
- static _Res
- _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
- {
- return _GLIBCXX_TR1::
- mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
- }
- };
-
- template<typename _Class, typename _Member, typename... _ArgTypes>
- class _Function_handler<void(_ArgTypes...), _Member _Class::*>
- : public _Function_base::_Base_manager<
- _Simple_type_wrapper< _Member _Class::* > >
- {
- typedef _Member _Class::* _Functor;
- typedef _Simple_type_wrapper<_Functor> _Wrapper;
- typedef _Function_base::_Base_manager<_Wrapper> _Base;
-
- public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
- _Manager_operation __op)
- {
- switch (__op)
- {
- case __get_type_info:
- __dest._M_access<const type_info*>() = &typeid(_Functor);
- break;
-
- case __get_functor_ptr:
- __dest._M_access<_Functor*>() =
- &_Base::_M_get_pointer(__source)->__value;
- break;
-
- default:
- _Base::_M_manager(__dest, __source, __op);
- }
- return false;
- }
-
- static void
- _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
- {
- _GLIBCXX_TR1::
- mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
- }
- };
-
- template<typename _Res, typename... _ArgTypes>
- class function<_Res(_ArgTypes...)>
- : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
- private _Function_base
- {
- /**
- * @if maint
- * This class is used to implement the safe_bool idiom.
- * @endif
- */
- struct _Hidden_type
- {
- _Hidden_type* _M_bool;
- };
-
- /**
- * @if maint
- * This typedef is used to implement the safe_bool idiom.
- * @endif
- */
- typedef _Hidden_type* _Hidden_type::* _Safe_bool;
-
- typedef _Res _Signature_type(_ArgTypes...);
-
- struct _Useless {};
-
- public:
- typedef _Res result_type;
-
- // [3.7.2.1] construct/copy/destroy
-
- /**
- * @brief Default construct creates an empty function call wrapper.
- * @post @c !(bool)*this
- */
- function() : _Function_base() { }
-
- /**
- * @brief Default construct creates an empty function call wrapper.
- * @post @c !(bool)*this
- */
- function(_M_clear_type*) : _Function_base() { }
-
- /**
- * @brief %Function copy constructor.
- * @param x A %function object with identical call signature.
- * @pre @c (bool)*this == (bool)x
- *
- * The newly-created %function contains a copy of the target of @a
- * x (if it has one).
- */
- function(const function& __x);
-
- /**
- * @brief Builds a %function that targets a copy of the incoming
- * function object.
- * @param f A %function object that is callable with parameters of
- * type @c T1, @c T2, ..., @c TN and returns a value convertible
- * to @c Res.
- *
- * The newly-created %function object will target a copy of @a
- * f. If @a f is @c reference_wrapper<F>, then this function
- * object will contain a reference to the function object @c
- * f.get(). If @a f is a NULL function pointer or NULL
- * pointer-to-member, the newly-created object will be empty.
- *
- * If @a f is a non-NULL function pointer or an object of type @c
- * reference_wrapper<F>, this function will not throw.
- */
- template<typename _Functor>
- function(_Functor __f,
- typename __gnu_cxx::__enable_if<
- !is_integral<_Functor>::value, _Useless>::__type
- = _Useless());
-
- /**
- * @brief %Function assignment operator.
- * @param x A %function with identical call signature.
- * @post @c (bool)*this == (bool)x
- * @returns @c *this
- *
- * The target of @a x is copied to @c *this. If @a x has no
- * target, then @c *this will be empty.
- *
- * If @a x targets a function pointer or a reference to a function
- * object, then this operation will not throw an exception.
- */
- function&
- operator=(const function& __x)
- {
- function(__x).swap(*this);
- return *this;
- }
-
- /**
- * @brief %Function assignment to zero.
- * @post @c !(bool)*this
- * @returns @c *this
- *
- * The target of @a *this is deallocated, leaving it empty.
- */
- function&
- operator=(_M_clear_type*)
- {
- if (_M_manager)
- {
- _M_manager(_M_functor, _M_functor, __destroy_functor);
- _M_manager = 0;
- _M_invoker = 0;
- }
- return *this;
- }
-
- /**
- * @brief %Function assignment to a new target.
- * @param f A %function object that is callable with parameters of
- * type @c T1, @c T2, ..., @c TN and returns a value convertible
- * to @c Res.
- * @return @c *this
- *
- * This %function object wrapper will target a copy of @a
- * f. If @a f is @c reference_wrapper<F>, then this function
- * object will contain a reference to the function object @c
- * f.get(). If @a f is a NULL function pointer or NULL
- * pointer-to-member, @c this object will be empty.
- *
- * If @a f is a non-NULL function pointer or an object of type @c
- * reference_wrapper<F>, this function will not throw.
- */
- template<typename _Functor>
- typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
- function&>::__type
- operator=(_Functor __f)
- {
- function(__f).swap(*this);
- return *this;
- }
-
- // [3.7.2.2] function modifiers
-
- /**
- * @brief Swap the targets of two %function objects.
- * @param f A %function with identical call signature.
- *
- * Swap the targets of @c this function object and @a f. This
- * function will not throw an exception.
- */
- void swap(function& __x)
- {
- _Any_data __old_functor = _M_functor;
- _M_functor = __x._M_functor;
- __x._M_functor = __old_functor;
- _Manager_type __old_manager = _M_manager;
- _M_manager = __x._M_manager;
- __x._M_manager = __old_manager;
- _Invoker_type __old_invoker = _M_invoker;
- _M_invoker = __x._M_invoker;
- __x._M_invoker = __old_invoker;
- }
-
- // [3.7.2.3] function capacity
-
- /**
- * @brief Determine if the %function wrapper has a target.
- *
- * @return @c true when this %function object contains a target,
- * or @c false when it is empty.
- *
- * This function will not throw an exception.
- */
- operator _Safe_bool() const
- {
- if (_M_empty())
- return 0;
- else
- return &_Hidden_type::_M_bool;
- }
-
- // [3.7.2.4] function invocation
-
- /**
- * @brief Invokes the function targeted by @c *this.
- * @returns the result of the target.
- * @throws bad_function_call when @c !(bool)*this
- *
- * The function call operator invokes the target function object
- * stored by @c this.
- */
- _Res operator()(_ArgTypes... __args) const;
-
- // [3.7.2.5] function target access
- /**
- * @brief Determine the type of the target of this function object
- * wrapper.
- *
- * @returns the type identifier of the target function object, or
- * @c typeid(void) if @c !(bool)*this.
- *
- * This function will not throw an exception.
- */
- const type_info& target_type() const;
-
- /**
- * @brief Access the stored target function object.
- *
- * @return Returns a pointer to the stored target function object,
- * if @c typeid(Functor).equals(target_type()); otherwise, a NULL
- * pointer.
- *
- * This function will not throw an exception.
- */
- template<typename _Functor> _Functor* target();
-
- /**
- * @overload
- */
- template<typename _Functor> const _Functor* target() const;
-
- private:
- // [3.7.2.6] undefined operators
- template<typename _Function>
- void operator==(const function<_Function>&) const;
- template<typename _Function>
- void operator!=(const function<_Function>&) const;
-
- typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
- _Invoker_type _M_invoker;
- };
-
- template<typename _Res, typename... _ArgTypes>
- function<_Res(_ArgTypes...)>::
- function(const function& __x)
- : _Function_base()
- {
- if (__x)
- {
- _M_invoker = __x._M_invoker;
- _M_manager = __x._M_manager;
- __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
- }
- }
-
- template<typename _Res, typename... _ArgTypes>
- template<typename _Functor>
- function<_Res(_ArgTypes...)>::
- function(_Functor __f,
- typename __gnu_cxx::__enable_if<
- !is_integral<_Functor>::value, _Useless>::__type)
- : _Function_base()
- {
- typedef _Function_handler<_Signature_type, _Functor> _My_handler;
-
- if (_My_handler::_M_not_empty_function(__f))
- {
- _M_invoker = &_My_handler::_M_invoke;
- _M_manager = &_My_handler::_M_manager;
- _My_handler::_M_init_functor(_M_functor, __f);
- }
- }
+#include <tr1/functional_hash.h>
- template<typename _Res, typename... _ArgTypes>
- _Res
- function<_Res(_ArgTypes...)>::
- operator()(_ArgTypes... __args) const
- {
- if (_M_empty())
- {
-#if __EXCEPTIONS
- throw bad_function_call();
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/functional>
#else
- __builtin_abort();
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/functional>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
- }
- return _M_invoker(_M_functor, __args...);
- }
-
- template<typename _Res, typename... _ArgTypes>
- const type_info&
- function<_Res(_ArgTypes...)>::
- target_type() const
- {
- if (_M_manager)
- {
- _Any_data __typeinfo_result;
- _M_manager(__typeinfo_result, _M_functor, __get_type_info);
- return *__typeinfo_result._M_access<const type_info*>();
- }
- else
- return typeid(void);
- }
-
- template<typename _Res, typename... _ArgTypes>
- template<typename _Functor>
- _Functor*
- function<_Res(_ArgTypes...)>::
- target()
- {
- if (typeid(_Functor) == target_type() && _M_manager)
- {
- _Any_data __ptr;
- if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
- && !is_const<_Functor>::value)
- return 0;
- else
- return __ptr._M_access<_Functor*>();
- }
- else
- return 0;
- }
-
- template<typename _Res, typename... _ArgTypes>
- template<typename _Functor>
- const _Functor*
- function<_Res(_ArgTypes...)>::
- target() const
- {
- if (typeid(_Functor) == target_type() && _M_manager)
- {
- _Any_data __ptr;
- _M_manager(__ptr, _M_functor, __get_functor_ptr);
- return __ptr._M_access<const _Functor*>();
- }
- else
- return 0;
- }
-
- // [3.7.2.7] null pointer comparisons
-
- /**
- * @brief Compares a polymorphic function object wrapper against 0
- * (the NULL pointer).
- * @returns @c true if the wrapper has no target, @c false otherwise
- *
- * This function will not throw an exception.
- */
- template<typename _Signature>
- inline bool
- operator==(const function<_Signature>& __f, _M_clear_type*)
- {
- return !__f;
- }
-
- /**
- * @overload
- */
- template<typename _Signature>
- inline bool
- operator==(_M_clear_type*, const function<_Signature>& __f)
- {
- return !__f;
- }
- /**
- * @brief Compares a polymorphic function object wrapper against 0
- * (the NULL pointer).
- * @returns @c false if the wrapper has no target, @c true otherwise
- *
- * This function will not throw an exception.
- */
- template<typename _Signature>
- inline bool
- operator!=(const function<_Signature>& __f, _M_clear_type*)
- {
- return __f;
- }
-
- /**
- * @overload
- */
- template<typename _Signature>
- inline bool
- operator!=(_M_clear_type*, const function<_Signature>& __f)
- {
- return __f;
- }
-
- // [3.7.2.8] specialized algorithms
-
- /**
- * @brief Swap the targets of two polymorphic function object wrappers.
- *
- * This function will not throw an exception.
- */
- template<typename _Signature>
- inline void
- swap(function<_Signature>& __x, function<_Signature>& __y)
- {
- __x.swap(__y);
- }
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#include <tr1/functional_hash.h>
-
-#endif
+#endif // _GLIBCXX_TR1_FUNCTIONAL
-// TR1 functional -*- C++ -*-
+// TR1 functional_hash.h header -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
//
* You should not attempt to use it directly.
*/
-#ifndef _TR1_FUNCTIONAL_HASH_H
-#define _TR1_FUNCTIONAL_HASH_H 1
+#ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H
+#define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1
-#include <string>
-#include <cmath> // for std::frexp
+#pragma GCC system_header
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // Definition of default hash function std::tr1::hash<>. The types for
- // which std::tr1::hash<T> is defined is in clause 6.3.3. of the PDTR.
- template<typename T>
- struct hash;
-
-#define _TR1_hashtable_define_trivial_hash(_Tp) \
- template<> \
- struct hash<_Tp> \
- : public std::unary_function<_Tp, std::size_t> \
- { \
- std::size_t \
- operator()(_Tp __val) const \
- { return static_cast<std::size_t>(__val); } \
- }
-
- _TR1_hashtable_define_trivial_hash(bool);
- _TR1_hashtable_define_trivial_hash(char);
- _TR1_hashtable_define_trivial_hash(signed char);
- _TR1_hashtable_define_trivial_hash(unsigned char);
- _TR1_hashtable_define_trivial_hash(wchar_t);
- _TR1_hashtable_define_trivial_hash(short);
- _TR1_hashtable_define_trivial_hash(int);
- _TR1_hashtable_define_trivial_hash(long);
- _TR1_hashtable_define_trivial_hash(long long);
- _TR1_hashtable_define_trivial_hash(unsigned short);
- _TR1_hashtable_define_trivial_hash(unsigned int);
- _TR1_hashtable_define_trivial_hash(unsigned long);
- _TR1_hashtable_define_trivial_hash(unsigned long long);
-
-#undef _TR1_hashtable_define_trivial_hash
-
- template<typename _Tp>
- struct hash<_Tp*>
- : public std::unary_function<_Tp*, std::size_t>
- {
- std::size_t
- operator()(_Tp* __p) const
- { return reinterpret_cast<std::size_t>(__p); }
- };
-
- // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
- // (used by the next specializations of std::tr1::hash<>)
-
- // Dummy generic implementation (for sizeof(size_t) != 4, 8).
- template<std::size_t = sizeof(std::size_t)>
- struct _Fnv_hash
- {
- static std::size_t
- hash(const char* __first, std::size_t __length)
- {
- std::size_t __result = 0;
- for (; __length > 0; --__length)
- __result = (__result * 131) + *__first++;
- return __result;
- }
- };
-
- template<>
- struct _Fnv_hash<4>
- {
- static std::size_t
- hash(const char* __first, std::size_t __length)
- {
- std::size_t __result = static_cast<std::size_t>(2166136261UL);
- for (; __length > 0; --__length)
- {
- __result ^= static_cast<std::size_t>(*__first++);
- __result *= static_cast<std::size_t>(16777619UL);
- }
- return __result;
- }
- };
-
- template<>
- struct _Fnv_hash<8>
- {
- static std::size_t
- hash(const char* __first, std::size_t __length)
- {
- std::size_t __result =
- static_cast<std::size_t>(14695981039346656037ULL);
- for (; __length > 0; --__length)
- {
- __result ^= static_cast<std::size_t>(*__first++);
- __result *= static_cast<std::size_t>(1099511628211ULL);
- }
- return __result;
- }
- };
-
- // XXX String and floating point hashes probably shouldn't be inline
- // member functions, since are nontrivial. Once we have the framework
- // for TR1 .cc files, these should go in one.
- template<>
- struct hash<std::string>
- : public std::unary_function<std::string, std::size_t>
- {
- std::size_t
- operator()(const std::string& __s) const
- { return _Fnv_hash<>::hash(__s.data(), __s.length()); }
- };
-
-#ifdef _GLIBCXX_USE_WCHAR_T
- template<>
- struct hash<std::wstring>
- : public std::unary_function<std::wstring, std::size_t>
- {
- std::size_t
- operator()(const std::wstring& __s) const
- {
- return _Fnv_hash<>::hash(reinterpret_cast<const char*>(__s.data()),
- __s.length() * sizeof(wchar_t));
- }
- };
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
#endif
- template<>
- struct hash<float>
- : public std::unary_function<float, std::size_t>
- {
- std::size_t
- operator()(float __fval) const
- {
- std::size_t __result = 0;
-
- // 0 and -0 both hash to zero.
- if (__fval != 0.0f)
- __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__fval),
- sizeof(__fval));
- return __result;
- }
- };
-
- template<>
- struct hash<double>
- : public std::unary_function<double, std::size_t>
- {
- std::size_t
- operator()(double __dval) const
- {
- std::size_t __result = 0;
-
- // 0 and -0 both hash to zero.
- if (__dval != 0.0)
- __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__dval),
- sizeof(__dval));
- return __result;
- }
- };
-
- // For long double, careful with random padding bits (e.g., on x86,
- // 10 bytes -> 12 bytes) and resort to frexp.
- template<>
- struct hash<long double>
- : public std::unary_function<long double, std::size_t>
- {
- std::size_t
- operator()(long double __ldval) const
- {
- std::size_t __result = 0;
-
- int __exponent;
- __ldval = std::frexp(__ldval, &__exponent);
- __ldval = __ldval < 0.0l ? -(__ldval + 0.5l) : __ldval;
-
- const long double __mult =
- __gnu_cxx::__numeric_traits<std::size_t>::__max + 1.0l;
- __ldval *= __mult;
-
- // Try to use all the bits of the mantissa (really necessary only
- // on 32-bit targets, at least for 80-bit floating point formats).
- const std::size_t __hibits = (std::size_t)__ldval;
- __ldval = (__ldval - (long double)__hibits) * __mult;
-
- const std::size_t __coeff =
- __gnu_cxx::__numeric_traits<std::size_t>::__max / __LDBL_MAX_EXP__;
-
- __result = __hibits + (std::size_t)__ldval + __coeff * __exponent;
-
- return __result;
- }
- };
-
-_GLIBCXX_END_NAMESPACE
-}
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/functional_hash.h>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/functional_hash.h>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
+
+#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
/**
* @ingroup tr1_math_spec_func
= std::numeric_limits<_Tp>::max_exponent10
* std::log(_Tp(10)) - _Tp(1);
#if _GLIBCXX_USE_C99_MATH_TR1
- _Tp __coeff = std::_GLIBCXX_TR1::lgamma(_Tp(1 + __n))
- - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __k))
- - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __n - __k));
+ _Tp __coeff = std::tr1::lgamma(_Tp(1 + __n))
+ - std::tr1::lgamma(_Tp(1 + __k))
+ - std::tr1::lgamma(_Tp(1 + __n - __k));
#else
_Tp __coeff = __log_gamma(_Tp(1 + __n))
- __log_gamma(_Tp(1 + __k))
{
const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);
#if _GLIBCXX_USE_C99_MATH_TR1
- const _Tp __ln_nfact = std::_GLIBCXX_TR1::lgamma(_Tp(__n + 1));
+ const _Tp __ln_nfact = std::tr1::lgamma(_Tp(__n + 1));
#else
const _Tp __ln_nfact = __log_gamma(_Tp(__n + 1));
#endif
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
#endif // _TR1_GAMMA_TCC
--- /dev/null
+// TR1 hashtable.h header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/hashtable.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _GLIBCXX_TR1_HASHTABLE_H
+#define _GLIBCXX_TR1_HASHTABLE_H 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/hashtable>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/hashtable>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_HASHTABLE_H
// Section 6, pp. 555-566
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
-#ifndef _TR1_HYPERGEOMETRIC_TCC
-#define _TR1_HYPERGEOMETRIC_TCC 1
+#ifndef _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
+#define _GLIBCXX_TR1_HYPERGEOMETRIC_TCC 1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
__conf_hyperg(const _Tp __a, const _Tp __c, const _Tp __x)
{
#if _GLIBCXX_USE_C99_MATH_TR1
- const _Tp __c_nint = std::_GLIBCXX_TR1::nearbyint(__c);
+ const _Tp __c_nint = std::tr1::nearbyint(__c);
#else
const _Tp __c_nint = static_cast<int>(__c + _Tp(0.5L));
#endif
__hyperg(const _Tp __a, const _Tp __b, const _Tp __c, const _Tp __x)
{
#if _GLIBCXX_USE_C99_MATH_TR1
- const _Tp __a_nint = std::_GLIBCXX_TR1::nearbyint(__a);
- const _Tp __b_nint = std::_GLIBCXX_TR1::nearbyint(__b);
- const _Tp __c_nint = std::_GLIBCXX_TR1::nearbyint(__c);
+ const _Tp __a_nint = std::tr1::nearbyint(__a);
+ const _Tp __b_nint = std::tr1::nearbyint(__b);
+ const _Tp __c_nint = std::tr1::nearbyint(__c);
#else
const _Tp __a_nint = static_cast<int>(__a + _Tp(0.5L));
const _Tp __b_nint = static_cast<int>(__b + _Tp(0.5L));
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_HYPERGEOMETRIC_TCC
+#endif // _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
// TR1 inttypes.h -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_INTTYPES_H
-#define _TR1_INTTYPES_H 1
+#ifndef _GLIBCXX_TR1_INTTYPES_H
+#define _GLIBCXX_TR1_INTTYPES_H 1
#include <tr1/cinttypes>
-#endif
+#endif // _GLIBCXX_TR1_INTTYPES_H
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 252-254
-#ifndef _TR1_LEGENDRE_FUNCTION_TCC
-#define _TR1_LEGENDRE_FUNCTION_TCC 1
+#ifndef _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
+#define _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC 1
#include "special_function_util.h"
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));
#if _GLIBCXX_USE_C99_MATH_TR1
- const _Tp __lncirc = std::_GLIBCXX_TR1::log1p(-__x * __x);
+ const _Tp __lncirc = std::tr1::log1p(-__x * __x);
#else
const _Tp __lncirc = std::log(_Tp(1) - __x * __x);
#endif
// Gamma(m+1/2) / Gamma(m)
#if _GLIBCXX_USE_C99_MATH_TR1
- const _Tp __lnpoch = std::_GLIBCXX_TR1::lgamma(_Tp(__m + _Tp(0.5L)))
- - std::_GLIBCXX_TR1::lgamma(_Tp(__m));
+ const _Tp __lnpoch = std::tr1::lgamma(_Tp(__m + _Tp(0.5L)))
+ - std::tr1::lgamma(_Tp(__m));
#else
const _Tp __lnpoch = __log_gamma(_Tp(__m + _Tp(0.5L)))
- __log_gamma(_Tp(__m));
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_LEGENDRE_FUNCTION_TCC
+#endif // _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_MATH_H
-#define _TR1_MATH_H 1
+#ifndef _GLIBCXX_TR1_MATH_H
+#define _GLIBCXX_TR1_MATH_H 1
#include <tr1/cmath>
#if _GLIBCXX_USE_C99_MATH_TR1
-using std::_GLIBCXX_TR1::acos;
-using std::_GLIBCXX_TR1::acosh;
-using std::_GLIBCXX_TR1::asin;
-using std::_GLIBCXX_TR1::asinh;
-using std::_GLIBCXX_TR1::atan;
-using std::_GLIBCXX_TR1::atan2;
-using std::_GLIBCXX_TR1::atanh;
-using std::_GLIBCXX_TR1::cbrt;
-using std::_GLIBCXX_TR1::ceil;
-using std::_GLIBCXX_TR1::copysign;
-using std::_GLIBCXX_TR1::cos;
-using std::_GLIBCXX_TR1::cosh;
-using std::_GLIBCXX_TR1::erf;
-using std::_GLIBCXX_TR1::erfc;
-using std::_GLIBCXX_TR1::exp;
-using std::_GLIBCXX_TR1::exp2;
-using std::_GLIBCXX_TR1::expm1;
-using std::_GLIBCXX_TR1::fabs;
-using std::_GLIBCXX_TR1::fdim;
-using std::_GLIBCXX_TR1::floor;
-using std::_GLIBCXX_TR1::fma;
-using std::_GLIBCXX_TR1::fmax;
-using std::_GLIBCXX_TR1::fmin;
-using std::_GLIBCXX_TR1::fmod;
-using std::_GLIBCXX_TR1::frexp;
-using std::_GLIBCXX_TR1::hypot;
-using std::_GLIBCXX_TR1::ilogb;
-using std::_GLIBCXX_TR1::ldexp;
-using std::_GLIBCXX_TR1::lgamma;
-using std::_GLIBCXX_TR1::llrint;
-using std::_GLIBCXX_TR1::llround;
-using std::_GLIBCXX_TR1::log;
-using std::_GLIBCXX_TR1::log10;
-using std::_GLIBCXX_TR1::log1p;
-using std::_GLIBCXX_TR1::log2;
-using std::_GLIBCXX_TR1::logb;
-using std::_GLIBCXX_TR1::lrint;
-using std::_GLIBCXX_TR1::lround;
-using std::_GLIBCXX_TR1::nearbyint;
-using std::_GLIBCXX_TR1::nextafter;
-using std::_GLIBCXX_TR1::nexttoward;
-using std::_GLIBCXX_TR1::pow;
-using std::_GLIBCXX_TR1::remainder;
-using std::_GLIBCXX_TR1::remquo;
-using std::_GLIBCXX_TR1::rint;
-using std::_GLIBCXX_TR1::round;
-using std::_GLIBCXX_TR1::scalbln;
-using std::_GLIBCXX_TR1::scalbn;
-using std::_GLIBCXX_TR1::sin;
-using std::_GLIBCXX_TR1::sinh;
-using std::_GLIBCXX_TR1::sqrt;
-using std::_GLIBCXX_TR1::tan;
-using std::_GLIBCXX_TR1::tanh;
-using std::_GLIBCXX_TR1::tgamma;
-using std::_GLIBCXX_TR1::trunc;
+using std::tr1::acos;
+using std::tr1::acosh;
+using std::tr1::asin;
+using std::tr1::asinh;
+using std::tr1::atan;
+using std::tr1::atan2;
+using std::tr1::atanh;
+using std::tr1::cbrt;
+using std::tr1::ceil;
+using std::tr1::copysign;
+using std::tr1::cos;
+using std::tr1::cosh;
+using std::tr1::erf;
+using std::tr1::erfc;
+using std::tr1::exp;
+using std::tr1::exp2;
+using std::tr1::expm1;
+using std::tr1::fabs;
+using std::tr1::fdim;
+using std::tr1::floor;
+using std::tr1::fma;
+using std::tr1::fmax;
+using std::tr1::fmin;
+using std::tr1::fmod;
+using std::tr1::frexp;
+using std::tr1::hypot;
+using std::tr1::ilogb;
+using std::tr1::ldexp;
+using std::tr1::lgamma;
+using std::tr1::llrint;
+using std::tr1::llround;
+using std::tr1::log;
+using std::tr1::log10;
+using std::tr1::log1p;
+using std::tr1::log2;
+using std::tr1::logb;
+using std::tr1::lrint;
+using std::tr1::lround;
+using std::tr1::nearbyint;
+using std::tr1::nextafter;
+using std::tr1::nexttoward;
+using std::tr1::pow;
+using std::tr1::remainder;
+using std::tr1::remquo;
+using std::tr1::rint;
+using std::tr1::round;
+using std::tr1::scalbln;
+using std::tr1::scalbn;
+using std::tr1::sin;
+using std::tr1::sinh;
+using std::tr1::sqrt;
+using std::tr1::tan;
+using std::tr1::tanh;
+using std::tr1::tgamma;
+using std::tr1::trunc;
#endif
-using std::_GLIBCXX_TR1::assoc_laguerref;
-using std::_GLIBCXX_TR1::assoc_laguerre;
-using std::_GLIBCXX_TR1::assoc_laguerrel;
+using std::tr1::assoc_laguerref;
+using std::tr1::assoc_laguerre;
+using std::tr1::assoc_laguerrel;
-using std::_GLIBCXX_TR1::assoc_legendref;
-using std::_GLIBCXX_TR1::assoc_legendre;
-using std::_GLIBCXX_TR1::assoc_legendrel;
+using std::tr1::assoc_legendref;
+using std::tr1::assoc_legendre;
+using std::tr1::assoc_legendrel;
-using std::_GLIBCXX_TR1::betaf;
-using std::_GLIBCXX_TR1::beta;
-using std::_GLIBCXX_TR1::betal;
+using std::tr1::betaf;
+using std::tr1::beta;
+using std::tr1::betal;
-using std::_GLIBCXX_TR1::comp_ellint_1f;
-using std::_GLIBCXX_TR1::comp_ellint_1;
-using std::_GLIBCXX_TR1::comp_ellint_1l;
+using std::tr1::comp_ellint_1f;
+using std::tr1::comp_ellint_1;
+using std::tr1::comp_ellint_1l;
-using std::_GLIBCXX_TR1::comp_ellint_2f;
-using std::_GLIBCXX_TR1::comp_ellint_2;
-using std::_GLIBCXX_TR1::comp_ellint_2l;
+using std::tr1::comp_ellint_2f;
+using std::tr1::comp_ellint_2;
+using std::tr1::comp_ellint_2l;
-using std::_GLIBCXX_TR1::comp_ellint_3f;
-using std::_GLIBCXX_TR1::comp_ellint_3;
-using std::_GLIBCXX_TR1::comp_ellint_3l;
+using std::tr1::comp_ellint_3f;
+using std::tr1::comp_ellint_3;
+using std::tr1::comp_ellint_3l;
-using std::_GLIBCXX_TR1::conf_hypergf;
-using std::_GLIBCXX_TR1::conf_hyperg;
-using std::_GLIBCXX_TR1::conf_hypergl;
+using std::tr1::conf_hypergf;
+using std::tr1::conf_hyperg;
+using std::tr1::conf_hypergl;
-using std::_GLIBCXX_TR1::cyl_bessel_if;
-using std::_GLIBCXX_TR1::cyl_bessel_i;
-using std::_GLIBCXX_TR1::cyl_bessel_il;
+using std::tr1::cyl_bessel_if;
+using std::tr1::cyl_bessel_i;
+using std::tr1::cyl_bessel_il;
-using std::_GLIBCXX_TR1::cyl_bessel_jf;
-using std::_GLIBCXX_TR1::cyl_bessel_j;
-using std::_GLIBCXX_TR1::cyl_bessel_jl;
+using std::tr1::cyl_bessel_jf;
+using std::tr1::cyl_bessel_j;
+using std::tr1::cyl_bessel_jl;
-using std::_GLIBCXX_TR1::cyl_bessel_kf;
-using std::_GLIBCXX_TR1::cyl_bessel_k;
-using std::_GLIBCXX_TR1::cyl_bessel_kl;
+using std::tr1::cyl_bessel_kf;
+using std::tr1::cyl_bessel_k;
+using std::tr1::cyl_bessel_kl;
-using std::_GLIBCXX_TR1::cyl_neumannf;
-using std::_GLIBCXX_TR1::cyl_neumann;
-using std::_GLIBCXX_TR1::cyl_neumannl;
+using std::tr1::cyl_neumannf;
+using std::tr1::cyl_neumann;
+using std::tr1::cyl_neumannl;
-using std::_GLIBCXX_TR1::ellint_1f;
-using std::_GLIBCXX_TR1::ellint_1;
-using std::_GLIBCXX_TR1::ellint_1l;
+using std::tr1::ellint_1f;
+using std::tr1::ellint_1;
+using std::tr1::ellint_1l;
-using std::_GLIBCXX_TR1::ellint_2f;
-using std::_GLIBCXX_TR1::ellint_2;
-using std::_GLIBCXX_TR1::ellint_2l;
+using std::tr1::ellint_2f;
+using std::tr1::ellint_2;
+using std::tr1::ellint_2l;
-using std::_GLIBCXX_TR1::ellint_3f;
-using std::_GLIBCXX_TR1::ellint_3;
-using std::_GLIBCXX_TR1::ellint_3l;
+using std::tr1::ellint_3f;
+using std::tr1::ellint_3;
+using std::tr1::ellint_3l;
-using std::_GLIBCXX_TR1::expintf;
-using std::_GLIBCXX_TR1::expint;
-using std::_GLIBCXX_TR1::expintl;
+using std::tr1::expintf;
+using std::tr1::expint;
+using std::tr1::expintl;
-using std::_GLIBCXX_TR1::hermitef;
-using std::_GLIBCXX_TR1::hermite;
-using std::_GLIBCXX_TR1::hermitel;
+using std::tr1::hermitef;
+using std::tr1::hermite;
+using std::tr1::hermitel;
-using std::_GLIBCXX_TR1::hypergf;
-using std::_GLIBCXX_TR1::hyperg;
-using std::_GLIBCXX_TR1::hypergl;
+using std::tr1::hypergf;
+using std::tr1::hyperg;
+using std::tr1::hypergl;
-using std::_GLIBCXX_TR1::laguerref;
-using std::_GLIBCXX_TR1::laguerre;
-using std::_GLIBCXX_TR1::laguerrel;
+using std::tr1::laguerref;
+using std::tr1::laguerre;
+using std::tr1::laguerrel;
-using std::_GLIBCXX_TR1::legendref;
-using std::_GLIBCXX_TR1::legendre;
-using std::_GLIBCXX_TR1::legendrel;
+using std::tr1::legendref;
+using std::tr1::legendre;
+using std::tr1::legendrel;
-using std::_GLIBCXX_TR1::riemann_zetaf;
-using std::_GLIBCXX_TR1::riemann_zeta;
-using std::_GLIBCXX_TR1::riemann_zetal;
+using std::tr1::riemann_zetaf;
+using std::tr1::riemann_zeta;
+using std::tr1::riemann_zetal;
-using std::_GLIBCXX_TR1::sph_besself;
-using std::_GLIBCXX_TR1::sph_bessel;
-using std::_GLIBCXX_TR1::sph_bessell;
+using std::tr1::sph_besself;
+using std::tr1::sph_bessel;
+using std::tr1::sph_bessell;
-using std::_GLIBCXX_TR1::sph_legendref;
-using std::_GLIBCXX_TR1::sph_legendre;
-using std::_GLIBCXX_TR1::sph_legendrel;
+using std::tr1::sph_legendref;
+using std::tr1::sph_legendre;
+using std::tr1::sph_legendrel;
-using std::_GLIBCXX_TR1::sph_neumannf;
-using std::_GLIBCXX_TR1::sph_neumann;
-using std::_GLIBCXX_TR1::sph_neumannl;
+using std::tr1::sph_neumannf;
+using std::tr1::sph_neumann;
+using std::tr1::sph_neumannl;
-#endif
+#endif // _GLIBCXX_TR1_MATH_H
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_MEMORY
-#define _TR1_MEMORY 1
+#ifndef _GLIBCXX_TR1_MEMORY
+#define _GLIBCXX_TR1_MEMORY 1
-#include <cstddef> // std::size_t
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
+
+#include <memory>
#include <exception> // std::exception
#include <new> // std::bad_alloc
#include <typeinfo> // std::type_info in get_deleter
#include <bits/stl_algobase.h> // std::swap
#include <iosfwd> // std::basic_ostream
-#include <memory>
-
#include <ext/atomicity.h>
#include <ext/concurrence.h>
#include <bits/functexcept.h>
#include <bits/stl_function.h> // std::less
#include <debug/debug.h>
+#include <tr1/type_traits>
-#include <tr1/type_traits> // tr1::add_reference
-#include <tr1/boost_shared_ptr.h>
-
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/boost_shared_ptr.h>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/boost_shared_ptr.h>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
+
+#endif // _GLIBCXX_TR1_MEMORY
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 246-249.
-#ifndef _TR1_MODIFIED_BESSEL_FUNC_TCC
-#define _TR1_MODIFIED_BESSEL_FUNC_TCC 1
+#ifndef _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
+#define _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC 1
#include "special_function_util.h"
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_MODIFIED_BESSEL_FUNC_TCC
+#endif // _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
// Ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications, Section 22 pp. 773-802
-#ifndef _TR1_POLY_HERMITE_TCC
-#define _TR1_POLY_HERMITE_TCC 1
+#ifndef _GLIBCXX_TR1_POLY_HERMITE_TCC
+#define _GLIBCXX_TR1_POLY_HERMITE_TCC 1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_POLY_HERMITE_TCC
+#endif // _GLIBCXX_TR1_POLY_HERMITE_TCC
// Section 13, pp. 509-510, Section 22 pp. 773-802
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
-#ifndef _TR1_POLY_LAGUERRE_TCC
-#define _TR1_POLY_LAGUERRE_TCC 1
+#ifndef _GLIBCXX_TR1_POLY_LAGUERRE_TCC
+#define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
* __eta * __eta * __cos2th * __sin2th;
#if _GLIBCXX_USE_C99_MATH_TR1
- const _Tp __lg_b = std::_GLIBCXX_TR1::lgamma(_Tp(__n) + __b);
- const _Tp __lnfact = std::_GLIBCXX_TR1::lgamma(_Tp(__n + 1));
+ const _Tp __lg_b = std::tr1::lgamma(_Tp(__n) + __b);
+ const _Tp __lnfact = std::tr1::lgamma(_Tp(__n + 1));
#else
const _Tp __lg_b = __log_gamma(_Tp(__n) + __b);
const _Tp __lnfact = __log_gamma(_Tp(__n + 1));
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_POLY_LAGUERRE_TCC
+#endif // _GLIBCXX_TR1_POLY_LAGUERRE_TCC
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_RANDOM
-#define _TR1_RANDOM 1
+#ifndef _GLIBCXX_TR1_RANDOM
+#define _GLIBCXX_TR1_RANDOM 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
#include <cmath>
#include <cstdio>
#include <string>
#include <iosfwd>
#include <limits>
-#include <tr1/type_traits>
-#include <tr1/cmath>
#include <ext/type_traits.h>
#include <ext/numeric_traits.h>
#include <bits/concept_check.h>
#include <debug/debug.h>
+#include <tr1/type_traits>
+#include <tr1/cmath>
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // [5.1] Random number generation
-
- /**
- * @addtogroup tr1_random Random Number Generation
- * A facility for generating random numbers on selected distributions.
- * @{
- */
-
- /*
- * Implementation-space details.
- */
- namespace __detail
- {
- template<typename _UIntType, int __w,
- bool = __w < std::numeric_limits<_UIntType>::digits>
- struct _Shift
- { static const _UIntType __value = 0; };
-
- template<typename _UIntType, int __w>
- struct _Shift<_UIntType, __w, true>
- { static const _UIntType __value = _UIntType(1) << __w; };
-
- template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
- struct _Mod;
-
- // Dispatch based on modulus value to prevent divide-by-zero compile-time
- // errors when m == 0.
- template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
- inline _Tp
- __mod(_Tp __x)
- { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); }
-
- typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
- unsigned, unsigned long>::__type _UInt32Type;
-
- /*
- * An adaptor class for converting the output of any Generator into
- * the input for a specific Distribution.
- */
- template<typename _Engine, typename _Distribution>
- struct _Adaptor
- {
- typedef typename _Engine::result_type _Engine_result_type;
- typedef typename _Distribution::input_type result_type;
-
- public:
- _Adaptor(const _Engine& __g)
- : _M_g(__g) { }
-
- result_type
- min() const
- {
- result_type __return_value = 0;
- if (is_integral<_Engine_result_type>::value
- && is_integral<result_type>::value)
- __return_value = _M_g.min();
- else if (!is_integral<result_type>::value)
- __return_value = result_type(0);
- return __return_value;
- }
-
- result_type
- max() const
- {
- result_type __return_value = 0;
- if (is_integral<_Engine_result_type>::value
- && is_integral<result_type>::value)
- __return_value = _M_g.max();
- else if (!is_integral<result_type>::value)
- __return_value = result_type(1);
- return __return_value;
- }
-
- result_type
- operator()();
-
- private:
- _Engine _M_g;
- };
-
- /*
- * Converts a value generated by the adapted random number generator into a
- * value in the input domain for the dependent random number distribution.
- *
- * Because the type traits are compile time constants only the appropriate
- * clause of the if statements will actually be emitted by the compiler.
- */
- template<typename _Engine, typename _Distribution>
- typename _Adaptor<_Engine, _Distribution>::result_type
- _Adaptor<_Engine, _Distribution>::
- operator()()
- {
- result_type __return_value = 0;
- if (is_integral<_Engine_result_type>::value
- && is_integral<result_type>::value)
- __return_value = _M_g();
- else if (is_integral<_Engine_result_type>::value
- && !is_integral<result_type>::value)
- __return_value = result_type(_M_g() - _M_g.min())
- / result_type(_M_g.max() - _M_g.min() + result_type(1));
- else if (!is_integral<_Engine_result_type>::value
- && !is_integral<result_type>::value)
- __return_value = result_type(_M_g() - _M_g.min())
- / result_type(_M_g.max() - _M_g.min());
- return __return_value;
- }
- } // namespace __detail
-
- /**
- * Produces random numbers on a given disribution function using a un uniform
- * random number generation engine.
- *
- * @todo the engine_value_type needs to be studied more carefully.
- */
- template<typename _Engine, typename _Dist>
- class variate_generator
- {
- // Concept requirements.
- __glibcxx_class_requires(_Engine, _CopyConstructibleConcept)
- // __glibcxx_class_requires(_Engine, _EngineConcept)
- // __glibcxx_class_requires(_Dist, _EngineConcept)
-
- public:
- typedef _Engine engine_type;
- typedef __detail::_Adaptor<_Engine, _Dist> engine_value_type;
- typedef _Dist distribution_type;
- typedef typename _Dist::result_type result_type;
-
- // tr1:5.1.1 table 5.1 requirement
- typedef typename __gnu_cxx::__enable_if<
- is_arithmetic<result_type>::value, result_type>::__type _IsValidType;
-
- /**
- * Constructs a variate generator with the uniform random number
- * generator @p __eng for the random distribution @p __dist.
- *
- * @throws Any exceptions which may thrown by the copy constructors of
- * the @p _Engine or @p _Dist objects.
- */
- variate_generator(engine_type __eng, distribution_type __dist)
- : _M_engine(__eng), _M_dist(__dist) { }
-
- /**
- * Gets the next generated value on the distribution.
- */
- result_type
- operator()()
- { return _M_dist(_M_engine); }
-
- /**
- * WTF?
- */
- template<typename _Tp>
- result_type
- operator()(_Tp __value)
- { return _M_dist(_M_engine, __value); }
-
- /**
- * Gets a reference to the underlying uniform random number generator
- * object.
- */
- engine_value_type&
- engine()
- { return _M_engine; }
-
- /**
- * Gets a const reference to the underlying uniform random number
- * generator object.
- */
- const engine_value_type&
- engine() const
- { return _M_engine; }
-
- /**
- * Gets a reference to the underlying random distribution.
- */
- distribution_type&
- distribution()
- { return _M_dist; }
-
- /**
- * Gets a const reference to the underlying random distribution.
- */
- const distribution_type&
- distribution() const
- { return _M_dist; }
-
- /**
- * Gets the closed lower bound of the distribution interval.
- */
- result_type
- min() const
- { return this->distribution().min(); }
-
- /**
- * Gets the closed upper bound of the distribution interval.
- */
- result_type
- max() const
- { return this->distribution().max(); }
-
- private:
- engine_value_type _M_engine;
- distribution_type _M_dist;
- };
-
-
- /**
- * @addtogroup tr1_random_generators Random Number Generators
- * @ingroup tr1_random
- *
- * These classes define objects which provide random or pseudorandom
- * numbers, either from a discrete or a continuous interval. The
- * random number generator supplied as a part of this library are
- * all uniform random number generators which provide a sequence of
- * random number uniformly distributed over their range.
- *
- * A number generator is a function object with an operator() that
- * takes zero arguments and returns a number.
- *
- * A compliant random number generator must satisy the following
- * requirements. <table border=1 cellpadding=10 cellspacing=0>
- * <caption align=top>Random Number Generator Requirements</caption>
- * <tr><td>To be documented.</td></tr> </table>
- *
- * @{
- */
-
- /**
- * @brief A model of a linear congruential random number generator.
- *
- * A random number generator that produces pseudorandom numbers using the
- * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$.
- *
- * The template parameter @p _UIntType must be an unsigned integral type
- * large enough to store values up to (__m-1). If the template parameter
- * @p __m is 0, the modulus @p __m used is
- * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
- * parameters @p __a and @p __c must be less than @p __m.
- *
- * The size of the state is @f$ 1 @f$.
- */
- template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
- class linear_congruential
- {
- __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
- // __glibcpp_class_requires(__a < __m && __c < __m)
-
- public:
- /** The type of the generated random value. */
- typedef _UIntType result_type;
-
- /** The multiplier. */
- static const _UIntType multiplier = __a;
- /** An increment. */
- static const _UIntType increment = __c;
- /** The modulus. */
- static const _UIntType modulus = __m;
-
- /**
- * Constructs a %linear_congruential random number generator engine with
- * seed @p __s. The default seed value is 1.
- *
- * @param __s The initial seed value.
- */
- explicit
- linear_congruential(unsigned long __x0 = 1)
- { this->seed(__x0); }
-
- /**
- * Constructs a %linear_congruential random number generator engine
- * seeded from the generator function @p __g.
- *
- * @param __g The seed generator function.
- */
- template<class _Gen>
- linear_congruential(_Gen& __g)
- { this->seed(__g); }
-
- /**
- * Reseeds the %linear_congruential random number generator engine
- * sequence to the seed @g __s.
- *
- * @param __s The new seed.
- */
- void
- seed(unsigned long __s = 1);
-
- /**
- * Reseeds the %linear_congruential random number generator engine
- * sequence using values from the generator function @p __g.
- *
- * @param __g the seed generator function.
- */
- template<class _Gen>
- void
- seed(_Gen& __g)
- { seed(__g, typename is_fundamental<_Gen>::type()); }
-
- /**
- * Gets the smallest possible value in the output range.
- *
- * The minumum depends on the @p __c parameter: if it is zero, the
- * minimum generated must be > 0, otherwise 0 is allowed.
- */
- result_type
- min() const
- { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
-
- /**
- * Gets the largest possible value in the output range.
- */
- result_type
- max() const
- { return __m - 1; }
-
- /**
- * Gets the next random number in the sequence.
- */
- result_type
- operator()();
-
- /**
- * Compares two linear congruential random number generator
- * objects of the same type for equality.
- *
- * @param __lhs A linear congruential random number generator object.
- * @param __rhs Another linear congruential random number generator obj.
- *
- * @returns true if the two objects are equal, false otherwise.
- */
- friend bool
- operator==(const linear_congruential& __lhs,
- const linear_congruential& __rhs)
- { return __lhs._M_x == __rhs._M_x; }
-
- /**
- * Compares two linear congruential random number generator
- * objects of the same type for inequality.
- *
- * @param __lhs A linear congruential random number generator object.
- * @param __rhs Another linear congruential random number generator obj.
- *
- * @returns true if the two objects are not equal, false otherwise.
- */
- friend bool
- operator!=(const linear_congruential& __lhs,
- const linear_congruential& __rhs)
- { return !(__lhs == __rhs); }
-
- /**
- * Writes the textual representation of the state x(i) of x to @p __os.
- *
- * @param __os The output stream.
- * @param __lcr A % linear_congruential random number generator.
- * @returns __os.
- */
- template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
- _UIntType1 __m1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const linear_congruential<_UIntType1, __a1, __c1,
- __m1>& __lcr);
-
- /**
- * Sets the state of the engine by reading its textual
- * representation from @p __is.
- *
- * The textual representation must have been previously written using an
- * output stream whose imbued locale and whose type's template
- * specialization arguments _CharT and _Traits were the same as those of
- * @p __is.
- *
- * @param __is The input stream.
- * @param __lcr A % linear_congruential random number generator.
- * @returns __is.
- */
- template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
- _UIntType1 __m1,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr);
-
- private:
- template<class _Gen>
- void
- seed(_Gen& __g, true_type)
- { return seed(static_cast<unsigned long>(__g)); }
-
- template<class _Gen>
- void
- seed(_Gen& __g, false_type);
-
- _UIntType _M_x;
- };
-
- /**
- * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
- */
- typedef linear_congruential<unsigned long, 16807, 0, 2147483647> minstd_rand0;
-
- /**
- * An alternative LCR (Lehmer Generator function) .
- */
- typedef linear_congruential<unsigned long, 48271, 0, 2147483647> minstd_rand;
-
-
- /**
- * A generalized feedback shift register discrete random number generator.
- *
- * This algorithm avoind multiplication and division and is designed to be
- * friendly to a pipelined architecture. If the parameters are chosen
- * correctly, this generator will produce numbers with a very long period and
- * fairly good apparent entropy, although still not cryptographically strong.
- *
- * The best way to use this generator is with the predefined mt19937 class.
- *
- * This algorithm was originally invented by Makoto Matsumoto and
- * Takuji Nishimura.
- *
- * @var word_size The number of bits in each element of the state vector.
- * @var state_size The degree of recursion.
- * @var shift_size The period parameter.
- * @var mask_bits The separation point bit index.
- * @var parameter_a The last row of the twist matrix.
- * @var output_u The first right-shift tempering matrix parameter.
- * @var output_s The first left-shift tempering matrix parameter.
- * @var output_b The first left-shift tempering matrix mask.
- * @var output_t The second left-shift tempering matrix parameter.
- * @var output_c The second left-shift tempering matrix mask.
- * @var output_l The second right-shift tempering matrix parameter.
- */
- template<class _UIntType, int __w, int __n, int __m, int __r,
- _UIntType __a, int __u, int __s, _UIntType __b, int __t,
- _UIntType __c, int __l>
- class mersenne_twister
- {
- __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
-
- public:
- // types
- typedef _UIntType result_type;
-
- // parameter values
- static const int word_size = __w;
- static const int state_size = __n;
- static const int shift_size = __m;
- static const int mask_bits = __r;
- static const _UIntType parameter_a = __a;
- static const int output_u = __u;
- static const int output_s = __s;
- static const _UIntType output_b = __b;
- static const int output_t = __t;
- static const _UIntType output_c = __c;
- static const int output_l = __l;
-
- // constructors and member function
- mersenne_twister()
- { seed(); }
-
- explicit
- mersenne_twister(unsigned long __value)
- { seed(__value); }
-
- template<class _Gen>
- mersenne_twister(_Gen& __g)
- { seed(__g); }
-
- void
- seed()
- { seed(5489UL); }
-
- void
- seed(unsigned long __value);
-
- template<class _Gen>
- void
- seed(_Gen& __g)
- { seed(__g, typename is_fundamental<_Gen>::type()); }
-
- result_type
- min() const
- { return 0; };
-
- result_type
- max() const
- { return __detail::_Shift<_UIntType, __w>::__value - 1; }
-
- result_type
- operator()();
-
- /**
- * Compares two % mersenne_twister random number generator objects of
- * the same type for equality.
- *
- * @param __lhs A % mersenne_twister random number generator object.
- * @param __rhs Another % mersenne_twister random number generator
- * object.
- *
- * @returns true if the two objects are equal, false otherwise.
- */
- friend bool
- operator==(const mersenne_twister& __lhs,
- const mersenne_twister& __rhs)
- { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); }
-
- /**
- * Compares two % mersenne_twister random number generator objects of
- * the same type for inequality.
- *
- * @param __lhs A % mersenne_twister random number generator object.
- * @param __rhs Another % mersenne_twister random number generator
- * object.
- *
- * @returns true if the two objects are not equal, false otherwise.
- */
- friend bool
- operator!=(const mersenne_twister& __lhs,
- const mersenne_twister& __rhs)
- { return !(__lhs == __rhs); }
-
- /**
- * Inserts the current state of a % mersenne_twister random number
- * generator engine @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A % mersenne_twister random number generator engine.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
- _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
- _UIntType1 __c1, int __l1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
- __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
-
- /**
- * Extracts the current state of a % mersenne_twister random number
- * generator engine @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A % mersenne_twister random number generator engine.
- *
- * @returns The input stream with the state of @p __x extracted or in
- * an error state.
- */
- template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
- _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
- _UIntType1 __c1, int __l1,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
- __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
-
- private:
- template<class _Gen>
- void
- seed(_Gen& __g, true_type)
- { return seed(static_cast<unsigned long>(__g)); }
-
- template<class _Gen>
- void
- seed(_Gen& __g, false_type);
-
- _UIntType _M_x[state_size];
- int _M_p;
- };
-
- /**
- * The classic Mersenne Twister.
- *
- * Reference:
- * M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
- * Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions
- * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
- */
- typedef mersenne_twister<
- unsigned long, 32, 624, 397, 31,
- 0x9908b0dful, 11, 7,
- 0x9d2c5680ul, 15,
- 0xefc60000ul, 18
- > mt19937;
-
-
- /**
- * @brief The Marsaglia-Zaman generator.
- *
- * This is a model of a Generalized Fibonacci discrete random number
- * generator, sometimes referred to as the SWC generator.
- *
- * A discrete random number generator that produces pseudorandom
- * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} -
- * carry_{i-1}) \bmod m @f$.
- *
- * The size of the state is @f$ r @f$
- * and the maximum period of the generator is @f$ m^r - m^s -1 @f$.
- *
- * N1688[4.13] says "the template parameter _IntType shall denote an integral
- * type large enough to store values up to m."
- *
- * @if maint
- * @var _M_x The state of the generator. This is a ring buffer.
- * @var _M_carry The carry.
- * @var _M_p Current index of x(i - r).
- * @endif
- */
- template<typename _IntType, _IntType __m, int __s, int __r>
- class subtract_with_carry
- {
- __glibcxx_class_requires(_IntType, _IntegerConcept)
-
- public:
- /** The type of the generated random value. */
- typedef _IntType result_type;
-
- // parameter values
- static const _IntType modulus = __m;
- static const int long_lag = __r;
- static const int short_lag = __s;
-
- /**
- * Constructs a default-initialized % subtract_with_carry random number
- * generator.
- */
- subtract_with_carry()
- { this->seed(); }
-
- /**
- * Constructs an explicitly seeded % subtract_with_carry random number
- * generator.
- */
- explicit
- subtract_with_carry(unsigned long __value)
- { this->seed(__value); }
-
- /**
- * Constructs a %subtract_with_carry random number generator engine
- * seeded from the generator function @p __g.
- *
- * @param __g The seed generator function.
- */
- template<class _Gen>
- subtract_with_carry(_Gen& __g)
- { this->seed(__g); }
-
- /**
- * Seeds the initial state @f$ x_0 @f$ of the random number generator.
- *
- * N1688[4.19] modifies this as follows. If @p __value == 0,
- * sets value to 19780503. In any case, with a linear
- * congruential generator lcg(i) having parameters @f$ m_{lcg} =
- * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
- * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
- * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$
- * set carry to 1, otherwise sets carry to 0.
- */
- void
- seed(unsigned long __value = 19780503);
-
- /**
- * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry
- * random number generator.
- */
- template<class _Gen>
- void
- seed(_Gen& __g)
- { seed(__g, typename is_fundamental<_Gen>::type()); }
-
- /**
- * Gets the inclusive minimum value of the range of random integers
- * returned by this generator.
- */
- result_type
- min() const
- { return 0; }
-
- /**
- * Gets the inclusive maximum value of the range of random integers
- * returned by this generator.
- */
- result_type
- max() const
- { return this->modulus - 1; }
-
- /**
- * Gets the next random number in the sequence.
- */
- result_type
- operator()();
-
- /**
- * Compares two % subtract_with_carry random number generator objects of
- * the same type for equality.
- *
- * @param __lhs A % subtract_with_carry random number generator object.
- * @param __rhs Another % subtract_with_carry random number generator
- * object.
- *
- * @returns true if the two objects are equal, false otherwise.
- */
- friend bool
- operator==(const subtract_with_carry& __lhs,
- const subtract_with_carry& __rhs)
- { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); }
-
- /**
- * Compares two % subtract_with_carry random number generator objects of
- * the same type for inequality.
- *
- * @param __lhs A % subtract_with_carry random number generator object.
- * @param __rhs Another % subtract_with_carry random number generator
- * object.
- *
- * @returns true if the two objects are not equal, false otherwise.
- */
- friend bool
- operator!=(const subtract_with_carry& __lhs,
- const subtract_with_carry& __rhs)
- { return !(__lhs == __rhs); }
-
- /**
- * Inserts the current state of a % subtract_with_carry random number
- * generator engine @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A % subtract_with_carry random number generator engine.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const subtract_with_carry<_IntType1, __m1, __s1,
- __r1>& __x);
-
- /**
- * Extracts the current state of a % subtract_with_carry random number
- * generator engine @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A % subtract_with_carry random number generator engine.
- *
- * @returns The input stream with the state of @p __x extracted or in
- * an error state.
- */
- template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x);
-
- private:
- template<class _Gen>
- void
- seed(_Gen& __g, true_type)
- { return seed(static_cast<unsigned long>(__g)); }
-
- template<class _Gen>
- void
- seed(_Gen& __g, false_type);
-
- typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType;
-
- _UIntType _M_x[long_lag];
- _UIntType _M_carry;
- int _M_p;
- };
-
-
- /**
- * @brief The Marsaglia-Zaman generator (floats version).
- *
- * @if maint
- * @var _M_x The state of the generator. This is a ring buffer.
- * @var _M_carry The carry.
- * @var _M_p Current index of x(i - r).
- * @var _M_npows Precomputed negative powers of 2.
- * @endif
- */
- template<typename _RealType, int __w, int __s, int __r>
- class subtract_with_carry_01
- {
- public:
- /** The type of the generated random value. */
- typedef _RealType result_type;
-
- // parameter values
- static const int word_size = __w;
- static const int long_lag = __r;
- static const int short_lag = __s;
-
- /**
- * Constructs a default-initialized % subtract_with_carry_01 random
- * number generator.
- */
- subtract_with_carry_01()
- {
- this->seed();
- _M_initialize_npows();
- }
-
- /**
- * Constructs an explicitly seeded % subtract_with_carry_01 random number
- * generator.
- */
- explicit
- subtract_with_carry_01(unsigned long __value)
- {
- this->seed(__value);
- _M_initialize_npows();
- }
-
- /**
- * Constructs a % subtract_with_carry_01 random number generator engine
- * seeded from the generator function @p __g.
- *
- * @param __g The seed generator function.
- */
- template<class _Gen>
- subtract_with_carry_01(_Gen& __g)
- {
- this->seed(__g);
- _M_initialize_npows();
- }
-
- /**
- * Seeds the initial state @f$ x_0 @f$ of the random number generator.
- */
- void
- seed(unsigned long __value = 19780503);
-
- /**
- * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry_01
- * random number generator.
- */
- template<class _Gen>
- void
- seed(_Gen& __g)
- { seed(__g, typename is_fundamental<_Gen>::type()); }
-
- /**
- * Gets the minimum value of the range of random floats
- * returned by this generator.
- */
- result_type
- min() const
- { return 0.0; }
-
- /**
- * Gets the maximum value of the range of random floats
- * returned by this generator.
- */
- result_type
- max() const
- { return 1.0; }
-
- /**
- * Gets the next random number in the sequence.
- */
- result_type
- operator()();
-
- /**
- * Compares two % subtract_with_carry_01 random number generator objects
- * of the same type for equality.
- *
- * @param __lhs A % subtract_with_carry_01 random number
- * generator object.
- * @param __rhs Another % subtract_with_carry_01 random number generator
- * object.
- *
- * @returns true if the two objects are equal, false otherwise.
- */
- friend bool
- operator==(const subtract_with_carry_01& __lhs,
- const subtract_with_carry_01& __rhs)
- {
- for (int __i = 0; __i < long_lag; ++__i)
- if (!std::equal(__lhs._M_x[__i], __lhs._M_x[__i] + __n,
- __rhs._M_x[__i]))
- return false;
- return true;
- }
-
- /**
- * Compares two % subtract_with_carry_01 random number generator objects
- * of the same type for inequality.
- *
- * @param __lhs A % subtract_with_carry_01 random number
- * generator object.
- *
- * @param __rhs Another % subtract_with_carry_01 random number generator
- * object.
- *
- * @returns true if the two objects are not equal, false otherwise.
- */
- friend bool
- operator!=(const subtract_with_carry_01& __lhs,
- const subtract_with_carry_01& __rhs)
- { return !(__lhs == __rhs); }
-
- /**
- * Inserts the current state of a % subtract_with_carry_01 random number
- * generator engine @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A % subtract_with_carry_01 random number generator engine.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType1, int __w1, int __s1, int __r1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const subtract_with_carry_01<_RealType1, __w1, __s1,
- __r1>& __x);
-
- /**
- * Extracts the current state of a % subtract_with_carry_01 random number
- * generator engine @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A % subtract_with_carry_01 random number generator engine.
- *
- * @returns The input stream with the state of @p __x extracted or in
- * an error state.
- */
- template<typename _RealType1, int __w1, int __s1, int __r1,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x);
-
- private:
- template<class _Gen>
- void
- seed(_Gen& __g, true_type)
- { return seed(static_cast<unsigned long>(__g)); }
-
- template<class _Gen>
- void
- seed(_Gen& __g, false_type);
-
- void
- _M_initialize_npows();
-
- static const int __n = (__w + 31) / 32;
-
- typedef __detail::_UInt32Type _UInt32Type;
- _UInt32Type _M_x[long_lag][__n];
- _RealType _M_npows[__n];
- _UInt32Type _M_carry;
- int _M_p;
- };
-
- typedef subtract_with_carry_01<float, 24, 10, 24> ranlux_base_01;
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 508. Bad parameters for ranlux64_base_01.
- typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;
-
-
- /**
- * Produces random numbers from some base engine by discarding blocks of
- * data.
- *
- * 0 <= @p __r <= @p __p
- */
- template<class _UniformRandomNumberGenerator, int __p, int __r>
- class discard_block
- {
- // __glibcxx_class_requires(typename base_type::result_type,
- // ArithmeticTypeConcept)
-
- public:
- /** The type of the underlying generator engine. */
- typedef _UniformRandomNumberGenerator base_type;
- /** The type of the generated random value. */
- typedef typename base_type::result_type result_type;
-
- // parameter values
- static const int block_size = __p;
- static const int used_block = __r;
-
- /**
- * Constructs a default %discard_block engine.
- *
- * The underlying engine is default constructed as well.
- */
- discard_block()
- : _M_n(0) { }
-
- /**
- * Copy constructs a %discard_block engine.
- *
- * Copies an existing base class random number geenerator.
- * @param rng An existing (base class) engine object.
- */
- explicit
- discard_block(const base_type& __rng)
- : _M_b(__rng), _M_n(0) { }
-
- /**
- * Seed constructs a %discard_block engine.
- *
- * Constructs the underlying generator engine seeded with @p __s.
- * @param __s A seed value for the base class engine.
- */
- explicit
- discard_block(unsigned long __s)
- : _M_b(__s), _M_n(0) { }
-
- /**
- * Generator construct a %discard_block engine.
- *
- * @param __g A seed generator function.
- */
- template<class _Gen>
- discard_block(_Gen& __g)
- : _M_b(__g), _M_n(0) { }
-
- /**
- * Reseeds the %discard_block object with the default seed for the
- * underlying base class generator engine.
- */
- void seed()
- {
- _M_b.seed();
- _M_n = 0;
- }
-
- /**
- * Reseeds the %discard_block object with the given seed generator
- * function.
- * @param __g A seed generator function.
- */
- template<class _Gen>
- void seed(_Gen& __g)
- {
- _M_b.seed(__g);
- _M_n = 0;
- }
-
- /**
- * Gets a const reference to the underlying generator engine object.
- */
- const base_type&
- base() const
- { return _M_b; }
-
- /**
- * Gets the minimum value in the generated random number range.
- */
- result_type
- min() const
- { return _M_b.min(); }
-
- /**
- * Gets the maximum value in the generated random number range.
- */
- result_type
- max() const
- { return _M_b.max(); }
-
- /**
- * Gets the next value in the generated random number sequence.
- */
- result_type
- operator()();
-
- /**
- * Compares two %discard_block random number generator objects of
- * the same type for equality.
- *
- * @param __lhs A %discard_block random number generator object.
- * @param __rhs Another %discard_block random number generator
- * object.
- *
- * @returns true if the two objects are equal, false otherwise.
- */
- friend bool
- operator==(const discard_block& __lhs, const discard_block& __rhs)
- { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
-
- /**
- * Compares two %discard_block random number generator objects of
- * the same type for inequality.
- *
- * @param __lhs A %discard_block random number generator object.
- * @param __rhs Another %discard_block random number generator
- * object.
- *
- * @returns true if the two objects are not equal, false otherwise.
- */
- friend bool
- operator!=(const discard_block& __lhs, const discard_block& __rhs)
- { return !(__lhs == __rhs); }
-
- /**
- * Inserts the current state of a %discard_block random number
- * generator engine @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %discard_block random number generator engine.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const discard_block<_UniformRandomNumberGenerator1,
- __p1, __r1>& __x);
-
- /**
- * Extracts the current state of a % subtract_with_carry random number
- * generator engine @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %discard_block random number generator engine.
- *
- * @returns The input stream with the state of @p __x extracted or in
- * an error state.
- */
- template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- discard_block<_UniformRandomNumberGenerator1,
- __p1, __r1>& __x);
-
- private:
- base_type _M_b;
- int _M_n;
- };
-
-
- /**
- * James's luxury-level-3 integer adaptation of Luescher's generator.
- */
- typedef discard_block<
- subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
- 223,
- 24
- > ranlux3;
-
- /**
- * James's luxury-level-4 integer adaptation of Luescher's generator.
- */
- typedef discard_block<
- subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
- 389,
- 24
- > ranlux4;
-
- typedef discard_block<
- subtract_with_carry_01<float, 24, 10, 24>,
- 223,
- 24
- > ranlux3_01;
-
- typedef discard_block<
- subtract_with_carry_01<float, 24, 10, 24>,
- 389,
- 24
- > ranlux4_01;
-
-
- /**
- * A random number generator adaptor class that combines two random number
- * generator engines into a single output sequence.
- */
- template<class _UniformRandomNumberGenerator1, int __s1,
- class _UniformRandomNumberGenerator2, int __s2>
- class xor_combine
- {
- // __glibcxx_class_requires(typename _UniformRandomNumberGenerator1::
- // result_type, ArithmeticTypeConcept)
- // __glibcxx_class_requires(typename _UniformRandomNumberGenerator2::
- // result_type, ArithmeticTypeConcept)
-
- public:
- /** The type of the the first underlying generator engine. */
- typedef _UniformRandomNumberGenerator1 base1_type;
- /** The type of the the second underlying generator engine. */
- typedef _UniformRandomNumberGenerator2 base2_type;
-
- private:
- typedef typename base1_type::result_type _Result_type1;
- typedef typename base2_type::result_type _Result_type2;
-
- public:
- /** The type of the generated random value. */
- typedef typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1)
- > sizeof(_Result_type2)),
- _Result_type1, _Result_type2>::__type result_type;
-
- // parameter values
- static const int shift1 = __s1;
- static const int shift2 = __s2;
-
- // constructors and member function
- xor_combine()
- : _M_b1(), _M_b2()
- { _M_initialize_max(); }
-
- xor_combine(const base1_type& __rng1, const base2_type& __rng2)
- : _M_b1(__rng1), _M_b2(__rng2)
- { _M_initialize_max(); }
-
- xor_combine(unsigned long __s)
- : _M_b1(__s), _M_b2(__s + 1)
- { _M_initialize_max(); }
-
- template<class _Gen>
- xor_combine(_Gen& __g)
- : _M_b1(__g), _M_b2(__g)
- { _M_initialize_max(); }
-
- void
- seed()
- {
- _M_b1.seed();
- _M_b2.seed();
- }
-
- template<class _Gen>
- void
- seed(_Gen& __g)
- {
- _M_b1.seed(__g);
- _M_b2.seed(__g);
- }
-
- const base1_type&
- base1() const
- { return _M_b1; }
-
- const base2_type&
- base2() const
- { return _M_b2; }
-
- result_type
- min() const
- { return 0; }
-
- result_type
- max() const
- { return _M_max; }
-
- /**
- * Gets the next random number in the sequence.
- */
- // NB: Not exactly the TR1 formula, per N2079 instead.
- result_type
- operator()()
- {
- return ((result_type(_M_b1() - _M_b1.min()) << shift1)
- ^ (result_type(_M_b2() - _M_b2.min()) << shift2));
- }
-
- /**
- * Compares two %xor_combine random number generator objects of
- * the same type for equality.
- *
- * @param __lhs A %xor_combine random number generator object.
- * @param __rhs Another %xor_combine random number generator
- * object.
- *
- * @returns true if the two objects are equal, false otherwise.
- */
- friend bool
- operator==(const xor_combine& __lhs, const xor_combine& __rhs)
- {
- return (__lhs.base1() == __rhs.base1())
- && (__lhs.base2() == __rhs.base2());
- }
-
- /**
- * Compares two %xor_combine random number generator objects of
- * the same type for inequality.
- *
- * @param __lhs A %xor_combine random number generator object.
- * @param __rhs Another %xor_combine random number generator
- * object.
- *
- * @returns true if the two objects are not equal, false otherwise.
- */
- friend bool
- operator!=(const xor_combine& __lhs, const xor_combine& __rhs)
- { return !(__lhs == __rhs); }
-
- /**
- * Inserts the current state of a %xor_combine random number
- * generator engine @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %xor_combine random number generator engine.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<class _UniformRandomNumberGenerator11, int __s11,
- class _UniformRandomNumberGenerator21, int __s21,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const xor_combine<_UniformRandomNumberGenerator11, __s11,
- _UniformRandomNumberGenerator21, __s21>& __x);
-
- /**
- * Extracts the current state of a %xor_combine random number
- * generator engine @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %xor_combine random number generator engine.
- *
- * @returns The input stream with the state of @p __x extracted or in
- * an error state.
- */
- template<class _UniformRandomNumberGenerator11, int __s11,
- class _UniformRandomNumberGenerator21, int __s21,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- xor_combine<_UniformRandomNumberGenerator11, __s11,
- _UniformRandomNumberGenerator21, __s21>& __x);
-
- private:
- void
- _M_initialize_max();
-
- result_type
- _M_initialize_max_aux(result_type, result_type, int);
-
- base1_type _M_b1;
- base2_type _M_b2;
- result_type _M_max;
- };
-
-
- /**
- * A standard interface to a platform-specific non-deterministic
- * random number generator (if any are available).
- */
- class random_device
- {
- public:
- // types
- typedef unsigned int result_type;
-
- // constructors, destructors and member functions
-
-#ifdef _GLIBCXX_USE_RANDOM_TR1
-
- explicit
- random_device(const std::string& __token = "/dev/urandom")
- {
- if ((__token != "/dev/urandom" && __token != "/dev/random")
- || !(_M_file = std::fopen(__token.c_str(), "rb")))
- std::__throw_runtime_error(__N("random_device::"
- "random_device(const std::string&)"));
- }
-
- ~random_device()
- { std::fclose(_M_file); }
-
-#else
-
- explicit
- random_device(const std::string& __token = "mt19937")
- : _M_mt(_M_strtoul(__token)) { }
-
- private:
- static unsigned long
- _M_strtoul(const std::string& __str)
- {
- unsigned long __ret = 5489UL;
- if (__str != "mt19937")
- {
- const char* __nptr = __str.c_str();
- char* __endptr;
- __ret = std::strtoul(__nptr, &__endptr, 0);
- if (*__nptr == '\0' || *__endptr != '\0')
- std::__throw_runtime_error(__N("random_device::_M_strtoul"
- "(const std::string&)"));
- }
- return __ret;
- }
-
- public:
-
-#endif
-
- result_type
- min() const
- { return std::numeric_limits<result_type>::min(); }
-
- result_type
- max() const
- { return std::numeric_limits<result_type>::max(); }
-
- double
- entropy() const
- { return 0.0; }
-
- result_type
- operator()()
- {
-#ifdef _GLIBCXX_USE_RANDOM_TR1
- result_type __ret;
- std::fread(reinterpret_cast<void*>(&__ret), sizeof(result_type),
- 1, _M_file);
- return __ret;
-#else
- return _M_mt();
-#endif
- }
-
- private:
- random_device(const random_device&);
- void operator=(const random_device&);
-
-#ifdef _GLIBCXX_USE_RANDOM_TR1
- FILE* _M_file;
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/random>
#else
- mt19937 _M_mt;
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/random>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
- };
-
- /* @} */ // group tr1_random_generators
-
- /**
- * @addtogroup tr1_random_distributions Random Number Distributions
- * @ingroup tr1_random
- * @{
- */
-
- /**
- * @addtogroup tr1_random_distributions_discrete Discrete Distributions
- * @ingroup tr1_random_distributions
- * @{
- */
-
- /**
- * @brief Uniform discrete distribution for random numbers.
- * A discrete random distribution on the range @f$[min, max]@f$ with equal
- * probability throughout the range.
- */
- template<typename _IntType = int>
- class uniform_int
- {
- __glibcxx_class_requires(_IntType, _IntegerConcept)
-
- public:
- /** The type of the parameters of the distribution. */
- typedef _IntType input_type;
- /** The type of the range of the distribution. */
- typedef _IntType result_type;
-
- public:
- /**
- * Constructs a uniform distribution object.
- */
- explicit
- uniform_int(_IntType __min = 0, _IntType __max = 9)
- : _M_min(__min), _M_max(__max)
- {
- _GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
- }
-
- /**
- * Gets the inclusive lower bound of the distribution range.
- */
- result_type
- min() const
- { return _M_min; }
-
- /**
- * Gets the inclusive upper bound of the distribution range.
- */
- result_type
- max() const
- { return _M_max; }
-
- /**
- * Resets the distribution state.
- *
- * Does nothing for the uniform integer distribution.
- */
- void
- reset() { }
-
- /**
- * Gets a uniformly distributed random number in the range
- * @f$(min, max)@f$.
- */
- template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- {
- typedef typename _UniformRandomNumberGenerator::result_type
- _UResult_type;
- return _M_call(__urng, _M_min, _M_max,
- typename is_integral<_UResult_type>::type());
- }
-
- /**
- * Gets a uniform random number in the range @f$[0, n)@f$.
- *
- * This function is aimed at use with std::random_shuffle.
- */
- template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng, result_type __n)
- {
- typedef typename _UniformRandomNumberGenerator::result_type
- _UResult_type;
- return _M_call(__urng, 0, __n - 1,
- typename is_integral<_UResult_type>::type());
- }
-
- /**
- * Inserts a %uniform_int random number distribution @p __x into the
- * output stream @p os.
- *
- * @param __os An output stream.
- * @param __x A %uniform_int random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _IntType1, typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const uniform_int<_IntType1>& __x);
-
- /**
- * Extracts a %unform_int random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %uniform_int random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _IntType1, typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- uniform_int<_IntType1>& __x);
-
- private:
- template<typename _UniformRandomNumberGenerator>
- result_type
- _M_call(_UniformRandomNumberGenerator& __urng,
- result_type __min, result_type __max, true_type)
- { return result_type(__urng() % (__max - __min + 1)) + __min; }
-
- template<typename _UniformRandomNumberGenerator>
- result_type
- _M_call(_UniformRandomNumberGenerator& __urng,
- result_type __min, result_type __max, false_type)
- {
- return result_type((__urng() - __urng.min())
- / (__urng.max() - __urng.min())
- * (__max - __min + 1)) + __min;
- }
-
- _IntType _M_min;
- _IntType _M_max;
- };
-
-
- /**
- * @brief A Bernoulli random number distribution.
- *
- * Generates a sequence of true and false values with likelihood @f$ p @f$
- * that true will come up and @f$ (1 - p) @f$ that false will appear.
- */
- class bernoulli_distribution
- {
- public:
- typedef int input_type;
- typedef bool result_type;
-
- public:
- /**
- * Constructs a Bernoulli distribution with likelihood @p p.
- *
- * @param __p [IN] The likelihood of a true result being returned. Must
- * be in the interval @f$ [0, 1] @f$.
- */
- explicit
- bernoulli_distribution(double __p = 0.5)
- : _M_p(__p)
- {
- _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
- }
-
- /**
- * Gets the @p p parameter of the distribution.
- */
- double
- p() const
- { return _M_p; }
-
- /**
- * Resets the distribution state.
- *
- * Does nothing for a bernoulli distribution.
- */
- void
- reset() { }
-
- /**
- * Gets the next value in the Bernoullian sequence.
- */
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- {
- if ((__urng() - __urng.min()) < _M_p * (__urng.max() - __urng.min()))
- return true;
- return false;
- }
-
- /**
- * Inserts a %bernoulli_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %bernoulli_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const bernoulli_distribution& __x);
-
- /**
- * Extracts a %bernoulli_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %bernoulli_distribution random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- bernoulli_distribution& __x)
- { return __is >> __x._M_p; }
-
- private:
- double _M_p;
- };
-
-
- /**
- * @brief A discrete geometric random number distribution.
- *
- * The formula for the geometric probability mass function is
- * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
- * distribution.
- */
- template<typename _IntType = int, typename _RealType = double>
- class geometric_distribution
- {
- public:
- // types
- typedef _RealType input_type;
- typedef _IntType result_type;
-
- // constructors and member function
- explicit
- geometric_distribution(const _RealType& __p = _RealType(0.5))
- : _M_p(__p)
- {
- _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
- _M_initialize();
- }
-
- /**
- * Gets the distribution parameter @p p.
- */
- _RealType
- p() const
- { return _M_p; }
-
- void
- reset() { }
-
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng);
-
- /**
- * Inserts a %geometric_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %geometric_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _IntType1, typename _RealType1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const geometric_distribution<_IntType1, _RealType1>& __x);
-
- /**
- * Extracts a %geometric_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %geometric_distribution random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- geometric_distribution& __x)
- {
- __is >> __x._M_p;
- __x._M_initialize();
- return __is;
- }
-
- private:
- void
- _M_initialize()
- { _M_log_p = std::log(_M_p); }
-
- _RealType _M_p;
- _RealType _M_log_p;
- };
-
-
- template<typename _RealType>
- class normal_distribution;
-
- /**
- * @brief A discrete Poisson random number distribution.
- *
- * The formula for the poisson probability mass function is
- * @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the
- * parameter of the distribution.
- */
- template<typename _IntType = int, typename _RealType = double>
- class poisson_distribution
- {
- public:
- // types
- typedef _RealType input_type;
- typedef _IntType result_type;
-
- // constructors and member function
- explicit
- poisson_distribution(const _RealType& __mean = _RealType(1))
- : _M_mean(__mean), _M_nd()
- {
- _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
- _M_initialize();
- }
-
- /**
- * Gets the distribution parameter @p mean.
- */
- _RealType
- mean() const
- { return _M_mean; }
-
- void
- reset()
- { _M_nd.reset(); }
-
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng);
-
- /**
- * Inserts a %poisson_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %poisson_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _IntType1, typename _RealType1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const poisson_distribution<_IntType1, _RealType1>& __x);
-
- /**
- * Extracts a %poisson_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %poisson_distribution random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _IntType1, typename _RealType1,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- poisson_distribution<_IntType1, _RealType1>& __x);
-
- private:
- void
- _M_initialize();
-
- // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
- normal_distribution<_RealType> _M_nd;
-
- _RealType _M_mean;
-
- // Hosts either log(mean) or the threshold of the simple method.
- _RealType _M_lm_thr;
-#if _GLIBCXX_USE_C99_MATH_TR1
- _RealType _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
-#endif
- };
-
-
- /**
- * @brief A discrete binomial random number distribution.
- *
- * The formula for the binomial probability mass function is
- * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
- * and @f$ p @f$ are the parameters of the distribution.
- */
- template<typename _IntType = int, typename _RealType = double>
- class binomial_distribution
- {
- public:
- // types
- typedef _RealType input_type;
- typedef _IntType result_type;
-
- // constructors and member function
- explicit
- binomial_distribution(_IntType __t = 1,
- const _RealType& __p = _RealType(0.5))
- : _M_t(__t), _M_p(__p), _M_nd()
- {
- _GLIBCXX_DEBUG_ASSERT((_M_t >= 0) && (_M_p >= 0.0) && (_M_p <= 1.0));
- _M_initialize();
- }
-
- /**
- * Gets the distribution @p t parameter.
- */
- _IntType
- t() const
- { return _M_t; }
-
- /**
- * Gets the distribution @p p parameter.
- */
- _RealType
- p() const
- { return _M_p; }
-
- void
- reset()
- { _M_nd.reset(); }
-
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng);
-
- /**
- * Inserts a %binomial_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %binomial_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _IntType1, typename _RealType1,
- typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const binomial_distribution<_IntType1, _RealType1>& __x);
-
- /**
- * Extracts a %binomial_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %binomial_distribution random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _IntType1, typename _RealType1,
- typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- binomial_distribution<_IntType1, _RealType1>& __x);
-
- private:
- void
- _M_initialize();
-
- template<class _UniformRandomNumberGenerator>
- result_type
- _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
-
- // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
- normal_distribution<_RealType> _M_nd;
-
- _RealType _M_q;
-#if _GLIBCXX_USE_C99_MATH_TR1
- _RealType _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
- _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
-#endif
- _RealType _M_p;
- _IntType _M_t;
-
- bool _M_easy;
- };
-
- /* @} */ // group tr1_random_distributions_discrete
-
- /**
- * @addtogroup tr1_random_distributions_continuous Continuous Distributions
- * @ingroup tr1_random_distributions
- * @{
- */
-
- /**
- * @brief Uniform continuous distribution for random numbers.
- *
- * A continuous random distribution on the range [min, max) with equal
- * probability throughout the range. The URNG should be real-valued and
- * deliver number in the range [0, 1).
- */
- template<typename _RealType = double>
- class uniform_real
- {
- public:
- // types
- typedef _RealType input_type;
- typedef _RealType result_type;
-
- public:
- /**
- * Constructs a uniform_real object.
- *
- * @param __min [IN] The lower bound of the distribution.
- * @param __max [IN] The upper bound of the distribution.
- */
- explicit
- uniform_real(_RealType __min = _RealType(0),
- _RealType __max = _RealType(1))
- : _M_min(__min), _M_max(__max)
- {
- _GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
- }
-
- result_type
- min() const
- { return _M_min; }
-
- result_type
- max() const
- { return _M_max; }
-
- void
- reset() { }
-
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- { return (__urng() * (_M_max - _M_min)) + _M_min; }
-
- /**
- * Inserts a %uniform_real random number distribution @p __x into the
- * output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %uniform_real random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType1, typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const uniform_real<_RealType1>& __x);
-
- /**
- * Extracts a %unform_real random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %uniform_real random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _RealType1, typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- uniform_real<_RealType1>& __x);
-
- private:
- _RealType _M_min;
- _RealType _M_max;
- };
-
-
- /**
- * @brief An exponential continuous distribution for random numbers.
- *
- * The formula for the exponential probability mass function is
- * @f$ p(x) = \lambda e^{-\lambda x} @f$.
- *
- * <table border=1 cellpadding=10 cellspacing=0>
- * <caption align=top>Distribution Statistics</caption>
- * <tr><td>Mean</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
- * <tr><td>Median</td><td>@f$ \frac{\ln 2}{\lambda} @f$</td></tr>
- * <tr><td>Mode</td><td>@f$ zero @f$</td></tr>
- * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
- * <tr><td>Standard Deviation</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
- * </table>
- */
- template<typename _RealType = double>
- class exponential_distribution
- {
- public:
- // types
- typedef _RealType input_type;
- typedef _RealType result_type;
-
- public:
- /**
- * Constructs an exponential distribution with inverse scale parameter
- * @f$ \lambda @f$.
- */
- explicit
- exponential_distribution(const result_type& __lambda = result_type(1))
- : _M_lambda(__lambda)
- {
- _GLIBCXX_DEBUG_ASSERT(_M_lambda > 0);
- }
-
- /**
- * Gets the inverse scale parameter of the distribution.
- */
- _RealType
- lambda() const
- { return _M_lambda; }
-
- /**
- * Resets the distribution.
- *
- * Has no effect on exponential distributions.
- */
- void
- reset() { }
-
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- { return -std::log(__urng()) / _M_lambda; }
-
- /**
- * Inserts a %exponential_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %exponential_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType1, typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const exponential_distribution<_RealType1>& __x);
-
- /**
- * Extracts a %exponential_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %exponential_distribution random number
- * generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- exponential_distribution& __x)
- { return __is >> __x._M_lambda; }
-
- private:
- result_type _M_lambda;
- };
-
-
- /**
- * @brief A normal continuous distribution for random numbers.
- *
- * The formula for the normal probability mass function is
- * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}}
- * e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$.
- */
- template<typename _RealType = double>
- class normal_distribution
- {
- public:
- // types
- typedef _RealType input_type;
- typedef _RealType result_type;
-
- public:
- /**
- * Constructs a normal distribution with parameters @f$ mean @f$ and
- * @f$ \sigma @f$.
- */
- explicit
- normal_distribution(const result_type& __mean = result_type(0),
- const result_type& __sigma = result_type(1))
- : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false)
- {
- _GLIBCXX_DEBUG_ASSERT(_M_sigma > 0);
- }
-
- /**
- * Gets the mean of the distribution.
- */
- _RealType
- mean() const
- { return _M_mean; }
-
- /**
- * Gets the @f$ \sigma @f$ of the distribution.
- */
- _RealType
- sigma() const
- { return _M_sigma; }
-
- /**
- * Resets the distribution.
- */
- void
- reset()
- { _M_saved_available = false; }
-
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng);
-
- /**
- * Inserts a %normal_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %normal_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType1, typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const normal_distribution<_RealType1>& __x);
-
- /**
- * Extracts a %normal_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %normal_distribution random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _RealType1, typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- normal_distribution<_RealType1>& __x);
-
- private:
- result_type _M_mean;
- result_type _M_sigma;
- result_type _M_saved;
- bool _M_saved_available;
- };
-
-
- /**
- * @brief A gamma continuous distribution for random numbers.
- *
- * The formula for the gamma probability mass function is
- * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$.
- */
- template<typename _RealType = double>
- class gamma_distribution
- {
- public:
- // types
- typedef _RealType input_type;
- typedef _RealType result_type;
-
- public:
- /**
- * Constructs a gamma distribution with parameters @f$ \alpha @f$.
- */
- explicit
- gamma_distribution(const result_type& __alpha_val = result_type(1))
- : _M_alpha(__alpha_val)
- {
- _GLIBCXX_DEBUG_ASSERT(_M_alpha > 0);
- _M_initialize();
- }
-
- /**
- * Gets the @f$ \alpha @f$ of the distribution.
- */
- _RealType
- alpha() const
- { return _M_alpha; }
-
- /**
- * Resets the distribution.
- */
- void
- reset() { }
-
- template<class _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng);
-
- /**
- * Inserts a %gamma_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %gamma_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType1, typename _CharT, typename _Traits>
- friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const gamma_distribution<_RealType1>& __x);
-
- /**
- * Extracts a %gamma_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %gamma_distribution random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _CharT, typename _Traits>
- friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- gamma_distribution& __x)
- {
- __is >> __x._M_alpha;
- __x._M_initialize();
- return __is;
- }
-
- private:
- void
- _M_initialize();
-
- result_type _M_alpha;
-
- // Hosts either lambda of GB or d of modified Vaduva's.
- result_type _M_l_d;
- };
-
- /* @} */ // group tr1_random_distributions_continuous
- /* @} */ // group tr1_random_distributions
- /* @} */ // group tr1_random
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#include <tr1/random.tcc>
-#endif // _TR1_RANDOM
+#endif // _GLIBCXX_TR1_RANDOM
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_REGEX
-#define _TR1_REGEX 1
+#ifndef _GLIBCXX_TR1_REGEX
+#define _GLIBCXX_TR1_REGEX 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
-#include <bits/c++config.h>
#include <algorithm>
#include <bitset>
#include <iterator>
#include <locale>
#include <stdexcept>
#include <string>
-#include <utility>
#include <vector>
+#include <utility>
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
-/**
- * @addtogroup tr1_regex Regular Expressions
- * A facility for performing regular expression pattern matching.
- * @{
- */
-
-namespace regex_constants
-{
- // [7.5.1] Bitmask Type syntax_option_type
- enum __syntax_option
- {
- _S_icase,
- _S_nosubs,
- _S_optimize,
- _S_collate,
- _S_ECMAScript,
- _S_basic,
- _S_extended,
- _S_awk,
- _S_grep,
- _S_egrep,
- _S_syntax_last
- };
-
- /**
- * @brief This is a bitmask type indicating how to interpret the regex.
- *
- * The @c syntax_option_type is implementation defined but it is valid to
- * perform bitwise operations on these values and expect the right thing to
- * happen.
- *
- * A valid value of type syntax_option_type shall have exactly one of the
- * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
- * set.
- */
- typedef unsigned int syntax_option_type;
-
- /// Specifies that the matching of regular expressions against a character
- /// sequence shall be performed without regard to case.
- static const syntax_option_type icase = 1 << _S_icase;
-
- /// Specifies that when a regular expression is matched against a character
- /// container sequence, no sub-expression matches are to be stored in the
- /// supplied match_results structure.
- static const syntax_option_type nosubs = 1 << _S_nosubs;
-
- /// Specifies that the regular expression engine should pay more attention to
- /// the speed with which regular expressions are matched, and less to the
- /// speed with which regular expression objects are constructed. Otherwise
- /// it has no detectable effect on the program output.
- static const syntax_option_type optimize = 1 << _S_optimize;
-
- /// Specifies that character ranges of the form [a-b] should be locale
- /// sensitive.
- static const syntax_option_type collate = 1 << _S_collate;
-
- /// Specifies that the grammar recognized by the regular expression engine is
- /// that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
- /// Language Specification, Standard Ecma-262, third edition, 1999], as
- /// modified in tr1 section [7.13]. This grammar is similar to that defined
- /// in the PERL scripting language but extended with elements found in the
- /// POSIX regular expression grammar.
- static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
-
- /// Specifies that the grammar recognized by the regular expression engine is
- /// that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
- /// Portable Operating System Interface (POSIX), Base Definitions and
- /// Headers, Section 9, Regular Expressions [IEEE, Information Technology --
- /// Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
- static const syntax_option_type basic = 1 << _S_basic;
-
- /// Specifies that the grammar recognized by the regular expression engine is
- /// that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
- /// Portable Operating System Interface (POSIX), Base Definitions and Headers,
- /// Section 9, Regular Expressions.
- static const syntax_option_type extended = 1 << _S_extended;
-
- /// Specifies that the grammar recognized by the regular expression engine is
- /// that used by POSIX utility awk in IEEE Std 1003.1-2001. This option is
- /// identical to syntax_option_type extended, except that C-style escape
- /// sequences are supported. These sequences are, explicitly, '\\', '\a',
- /// '\b', '\f', '\n', '\r', '\t' , '\v', '\"', '\\', and '\ddd' (where ddd is
- /// one, two, or three octal digits).
- static const syntax_option_type awk = 1 << _S_awk;
-
- /// Specifies that the grammar recognized by the regular expression engine is
- /// that used by POSIX utility grep in IEEE Std 1003.1-2001. This option is
- /// identical to syntax_option_type basic, except that newlines are treated
- /// as whitespace.
- static const syntax_option_type grep = 1 << _S_grep;
-
- /// Specifies that the grammar recognized by the regular expression engine is
- /// that used by POSIX utility grep when given the -E option in
- /// IEEE Std 1003.1-2001. This option is identical to syntax_option_type
- /// extended, except that newlines are treated as whitespace.
- static const syntax_option_type egrep = 1 << _S_egrep;
-
-
- // [7.5.2] Bitmask Type match_flag_type
- enum __match_flag
- {
- _S_not_bol,
- _S_not_eol,
- _S_not_bow,
- _S_not_eow,
- _S_any,
- _S_not_null,
- _S_continuous,
- _S_prev_avail,
- _S_sed,
- _S_no_copy,
- _S_first_only,
- _S_match_flag_last
- };
-
- /**
- * @brief This is a bitmask type indicating regex matching rules.
- *
- * Matching a regular expression against a sequence of characters [first,
- * last) proceeds according to the rules of the grammar specified for the
- * regular expression object, modified according to the effects listed
- * below for any bitmask elements set.
- *
- * The @c match_flag_type is implementation defined but it is valid to
- * perform bitwise operations on these values and expect the right thing to
- * happen.
- */
- typedef std::bitset<_S_match_flag_last> match_flag_type;
-
- static const match_flag_type match_default = 0;
-
- /// The first character in the sequence [first, last) is treated as though it
- /// is not at the beginning of a line, so the character "^" in the regular
- /// expression shall not match [first, first).
- static const match_flag_type match_not_bol = 1 << _S_not_bol;
-
- /// The last character in the sequence [first, last) is treated as though it
- /// is not at the end of a line, so the character "$" in the regular
- /// expression shall not match [last, last).
- static const match_flag_type match_not_eol = 1 << _S_not_eol;
-
- /// The expression "\b" is not matched against the sub-sequence
- /// [first,first).
- static const match_flag_type match_not_bow = 1 << _S_not_bow;
-
- /// The expression "\b" should not be matched against the sub-sequence
- /// [last,last).
- static const match_flag_type match_not_eow = 1 << _S_not_eow;
-
- /// If more than one match is possible then any match is an acceptable
- /// result.
- static const match_flag_type match_any = 1 << _S_any;
-
- /// The expression does not match an empty sequence.
- static const match_flag_type match_not_null = 1 << _S_not_null;
-
- /// The expression only matchs a sub-sequence that begins at first .
- static const match_flag_type match_continuous = 1 << _S_continuous;
-
- /// --first is a valid iterator position. When this flag is set then the
- /// flags match_not_bol and match_not_bow are ignored by the regular
- /// expression algorithms 7.11 and iterators 7.12.
- static const match_flag_type match_prev_avail = 1 << _S_prev_avail;
-
- /// When a regular expression match is to be replaced by a new string, the
- /// new string is constructed using the rules used by the ECMAScript replace
- /// function in ECMA- 262 [Ecma International, ECMAScript Language
- /// Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
- /// String.prototype.replace. In addition, during search and replace
- /// operations all non-overlapping occurrences of the regular expression
- /// are located and replaced, and sections of the input that did not match
- /// the expression are copied unchanged to the output string.
- ///
- /// Format strings (from ECMA-262 [15.5.4.11]):
- /// $$ $
- /// $& The matched substring.
- /// $` The portion of <em>string</em> that preceeds the matched substring.
- /// $' The portion of <em>string</em> that follows the matched substring.
- /// $n The nth capture, where n is in [1,9] and $n is not followed by a
- /// decimal digit. If n <= m and the nth capture is undefined, use the
- /// empty string
- /// instead. If n > m, the result is implementation-defined.
- /// $nn The nnth capture, where nn is a two-digit decimal number on [01, 99].
- /// If nn <= m and the nth capture is undefined, use the empty string
- /// instead. If nn > m, the result is implementation-defined.
- ///
- static const match_flag_type format_default = 0;
-
- /// When a regular expression match is to be replaced by a new string, the
- /// new string is constructed using the rules used by the POSIX sed utility
- /// in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
- /// Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
- static const match_flag_type format_sed = 1 << _S_sed;
-
- /// During a search and replace operation, sections of the character
- /// container sequence being searched that do not match the regular
- /// expression shall not be copied to the output string.
- static const match_flag_type format_no_copy = 1 << _S_no_copy;
-
- /// When specified during a search and replace operation, only the first
- /// occurrence of the regular expression shall be replaced.
- static const match_flag_type format_first_only = 1 << _S_first_only;
-
-
- // [7.5.3] implementation-defined error type
- enum error_type
- {
- _S_error_collate,
- _S_error_ctype,
- _S_error_escape,
- _S_error_backref,
- _S_error_brack,
- _S_error_paren,
- _S_error_brace,
- _S_error_badbrace,
- _S_error_range,
- _S_error_space,
- _S_error_badrepeat,
- _S_error_complexity,
- _S_error_stack,
- _S_error_last
- };
-
- /// The expression contained an invalid collating element name.
- static const error_type error_collate(_S_error_collate);
-
- /// The expression contained an invalid character class name.
- static const error_type error_ctype(_S_error_ctype);
-
- /// The expression contained an invalid escaped character, or a trailing
- /// escape.
- static const error_type error_escape(_S_error_escape);
-
- /// The expression contained an invalid back reference.
- static const error_type error_backref(_S_error_backref);
-
- /// The expression contained mismatched [ and ].
- static const error_type error_brack(_S_error_brack);
-
- /// The expression contained mismatched ( and ).
- static const error_type error_paren(_S_error_paren);
-
- /// The expression contained mismatched { and }
- static const error_type error_brace(_S_error_brace);
-
- /// The expression contained an invalid range in a {} expression.
- static const error_type error_badbrace(_S_error_badbrace);
-
- /// The expression contained an invalid character range,
- /// such as [b-a] in most encodings.
- static const error_type error_range(_S_error_range);
-
- /// There was insufficient memory to convert the expression into a
- /// finite state machine.
- static const error_type error_space(_S_error_space);
-
- /// One of *?+{ was not preceded by a valid regular expression.
- static const error_type error_badrepeat(_S_error_badrepeat);
-
- /// The complexity of an attempted match against a regular expression
- /// exceeded a pre-set level.
- static const error_type error_complexity(_S_error_complexity);
-
- /// There was insufficient memory to determine whether the
- /// regular expression could match the specified character sequence.
- static const error_type error_stack(_S_error_stack);
-}
-
-
- // [7.8] Class regex_error
- /**
- * Defines the type of objects thrown as exceptions to report errors from the
- * regular expression library.
- */
- class regex_error
- : public std::runtime_error
- {
- public:
- /**
- * @brief constructs a regex_error object.
- *
- * @param ecode the regex error code.
- */
- explicit
- regex_error(regex_constants::error_type __ecode)
- : std::runtime_error("regex_error"), _M_code(__ecode)
- { }
-
- /**
- * @brief gets the regex error code.
- *
- * @returns the regex error code.
- */
- regex_constants::error_type
- code() const
- { return _M_code; }
-
- protected:
- regex_constants::error_type _M_code;
- };
-
-
- // [7.7] Class regex_traits
- /**
- * A regular expression traits class that satisfies the requirements of tr1
- * section [7.2].
- *
- * The class %regex is parameterized around a set of related types and
- * functions used to complete the definition of its semantics. This class
- * satisfies the requirements of such a traits class.
- */
- template<typename _Ch_type>
- struct regex_traits
- {
- public:
- typedef _Ch_type char_type;
- typedef std::basic_string<char_type> string_type;
- typedef std::locale locale_type;
- typedef std::ctype_base::mask char_class_type;
-
- public:
- /**
- * @brief Constructs a default traits object.
- */
- regex_traits()
- { }
-
- /**
- * @brief Gives the length of a C-style string starting at @p __p.
- *
- * @param __p a pointer to the start of a character sequence.
- *
- * @returns the number of characters between @p *__p and the first
- * default-initialized value of type @p char_type. In other words, uses
- * the C-string algorithm for determiining the length of a sequence of
- * characters.
- */
- static std::size_t
- length(const char_type* __p)
- { return string_type::traits_type::length(__p); }
-
- /**
- * @brief Performs the identity translation.
- *
- * @param c A character to the locale-specific character set.
- *
- * @returns c.
- */
- char_type
- translate(char_type __c) const
- { return __c; }
-
- /**
- * @brief Translates a character into a case-insensitive equivalent.
- *
- * @param c A character to the locale-specific character set.
- *
- * @returns the locale-specific lower-case equivalent of c.
- * @throws std::bad_cast if the imbued locale does not support the ctype
- * facet.
- */
- char_type
- translate_nocase(char_type __c) const
- {
- using std::ctype;
- using std::use_facet;
- return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
- }
-
- /**
- * @brief Gets a sort key for a character sequence.
- *
- * @param first beginning of the character sequence.
- * @param last one-past-the-end of the character sequence.
- *
- * Returns a sort key for the character sequence designated by the
- * iterator range [F1, F2) such that if the character sequence [G1, G2)
- * sorts before the character sequence [H1, H2) then
- * v.transform(G1, G2) < v.transform(H1, H2).
- *
- * What this really does is provide a more efficient way to compare a
- * string to multiple other strings in locales with fancy collation
- * rules and equivalence classes.
- *
- * @returns a locale-specific sort key equivalent to the input range.
- *
- * @throws std::bad_cast if the current locale does not have a collate
- * facet.
- */
- template<typename _Fwd_iter>
- string_type
- transform(_Fwd_iter __first, _Fwd_iter __last) const
- {
- using std::collate;
- using std::use_facet;
- const collate<_Ch_type>& __c(use_facet<
- collate<_Ch_type> >(_M_locale));
- string_type __s(__first, __last);
- return __c.transform(__s.data(), __s.data() + __s.size());
- }
-
- /**
- * @brief Dunno.
- *
- * @param first beginning of the character sequence.
- * @param last one-past-the-end of the character sequence.
- *
- * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
- * typeid(collate_byname<_Ch_type>) and the form of the sort key
- * returned by collate_byname<_Ch_type>::transform(first, last) is known
- * and can be converted into a primary sort key then returns that key,
- * otherwise returns an empty string. WTF??
- *
- * @todo Implement this function.
- */
- template<typename _Fwd_iter>
- string_type
- transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
- { return string_type(); }
-
- /**
- * @breief Gets a collation element by name.
- *
- * @param first beginning of the collation element name.
- * @param last one-past-the-end of the collation element name.
- *
- * @returns a sequence of one or more characters that represents the
- * collating element consisting of the character sequence designated by
- * the iterator range [first, last). Returns an empty string if the
- * character sequence is not a valid collating element.
- *
- * @todo Implement this function.
- */
- template<typename _Fwd_iter>
- string_type
- lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
- { return string_type(); }
-
- /**
- * @brief Maps one or mire characters to a named character
- * classification.
- *
- * @param first beginning of the character sequence.
- * @param last one-past-the-end of the character sequence.
- *
- * @returns an unspecified value that represents the character
- * classification named by the character sequence designated by the
- * iterator range [first, last). The value returned shall be independent
- * of the case of the characters in the character sequence. If the name
- * is not recognized then returns a value that compares equal to 0.
- *
- * At least the following names (or their wide-character equivalent) are
- * supported.
- * - d
- * - w
- * - s
- * - alnum
- * - alpha
- * - blank
- * - cntrl
- * - digit
- * - graph
- * - lower
- * - print
- * - punct
- * - space
- * - upper
- * - xdigit
- *
- * @todo Implement this function.
- */
- template<typename _Fwd_iter>
- char_class_type
- lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const
- { return 0; }
-
- /**
- * @brief Determines if @p c is a member of an identified class.
- *
- * @param c a character.
- * @param f a class type (as returned from lookup_classname).
- *
- * @returns true if the character @p c is a member of the classification
- * represented by @p f, false otherwise.
- *
- * @throws std::bad_cast if the current locale does not have a ctype
- * facet.
- */
- bool
- isctype(_Ch_type __c, char_class_type __f) const
- {
- using std::ctype;
- using std::use_facet;
- const ctype<_Ch_type>& __ctype(use_facet<
- ctype<_Ch_type> >(_M_locale));
-
- if (__ctype.is(__c, __f))
- return true;
-
- // special case of underscore in [[:w:]]
- if (__c == __ctype.widen('_'))
- {
- const char* const __wb[] = "w";
- char_class_type __wt = this->lookup_classname(__wb,
- __wb + sizeof(__wb));
- if (__f | __wt)
- return true;
- }
-
- // special case of [[:space:]] in [[:blank:]]
- if (__c == __ctype.isspace(__c))
- {
- const char* const __bb[] = "blank";
- char_class_type __bt = this->lookup_classname(__bb,
- __bb + sizeof(__bb));
- if (__f | __bt)
- return true;
- }
-
- return false;
- }
-
- /**
- * @brief Converts a digit to an int.
- *
- * @param ch a character representing a digit.
- * @param radix the radix if the numeric conversion (limited to 8, 10,
- * or 16).
- *
- * @returns the value represented by the digit ch in base radix if the
- * character ch is a valid digit in base radix; otherwise returns -1.
- *
- * @todo Implement this function.
- */
- int
- value(_Ch_type __ch, int __radix) const;
-
- /**
- * @brief Imbues the regex_traits object with a copy of a new locale.
- *
- * @param loc A locale.
- *
- * @returns a copy of the previous locale in use by the regex_traits
- * object.
- *
- * @note Calling imbue with a different locale than the one currently in
- * use invalidates all cached data held by *this.
- */
- locale_type
- imbue(locale_type __loc)
- {
- std::swap(_M_locale, __loc);
- return __loc;
- }
-
- /**
- * @brief Gets a copy of the current locale in use by the regex_traits
- * object.
- */
- locale_type
- getloc() const
- { return _M_locale; }
-
- protected:
- locale_type _M_locale;
- };
-
-
- // [7.8] Class basic_regex
- /**
- * Objects of specializations of this class represent regular expressions
- * constructed from sequences of character type @p _Ch_type.
- *
- * Storage for the regular expression is allocated and deallocated as
- * necessary by the member functions of this class.
- */
- template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
- class basic_regex
- {
- public:
- // types:
- typedef _Ch_type value_type;
- typedef regex_constants::syntax_option_type flag_type;
- typedef typename _Rx_traits::locale_type locale_type;
- typedef typename _Rx_traits::string_type string_type;
-
- // [7.8.1] constants
- static const regex_constants::syntax_option_type icase
- = regex_constants::icase;
- static const regex_constants::syntax_option_type nosubs
- = regex_constants::nosubs;
- static const regex_constants::syntax_option_type optimize
- = regex_constants::optimize;
- static const regex_constants::syntax_option_type collate
- = regex_constants::collate;
- static const regex_constants::syntax_option_type ECMAScript
- = regex_constants::ECMAScript;
- static const regex_constants::syntax_option_type basic
- = regex_constants::basic;
- static const regex_constants::syntax_option_type extended
- = regex_constants::extended;
- static const regex_constants::syntax_option_type awk
- = regex_constants::awk;
- static const regex_constants::syntax_option_type grep
- = regex_constants::grep;
- static const regex_constants::syntax_option_type egrep
- = regex_constants::egrep;
-
- // [7.8.2] construct/copy/destroy
- /**
- * Constructs a basic regular expression that does not match any
- * character sequence.
- */
- basic_regex()
- : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
- { _M_compile(); }
-
- /**
- * @brief Constructs a basic regular expression from the sequence
- * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
- * flags in @p f.
- *
- * @param p A pointer to the start of a C-style null-terminated string
- * containing a regular expression.
- * @param f Flags indicating the syntax rules and options.
- *
- * @throws regex_error if @p p is not a valid regular expression.
- */
- explicit
- basic_regex(const _Ch_type* __p,
- flag_type __f = regex_constants::ECMAScript)
- : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
- { _M_compile(); }
-
- /**
- * @brief Constructs a basic regular expression from the sequence
- * [p, p + len) interpreted according to the flags in @p f.
- *
- * @param p A pointer to the start of a string containing a regular
- * expression.
- * @param len The length of the string containing the regular expression.
- * @param f Flags indicating the syntax rules and options.
- *
- * @throws regex_error if @p p is not a valid regular expression.
- */
- basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
- : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
- { _M_compile(); }
-
- /**
- * @brief Copy-contructs a basic regular expression.
- *
- * @param rhs A @p regex object.
- */
- basic_regex(const basic_regex& __rhs)
- : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
- _M_mark_count(__rhs._M_mark_count)
- { _M_compile(); }
-
- /**
- * @brief Constructs a basic regular expression from the string
- * @p interpreted according to the flags in @p f.
- *
- * @param p A string containing a regular expression.
- * @param f Flags indicating the syntax rules and options.
- *
- * @throws regex_error if @p p is not a valid regular expression.
- */
- template<typename _Ch_traits, typename _Ch_alloc>
- explicit
- basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
- flag_type __f = regex_constants::ECMAScript)
- : _M_flags(__f), _M_pattern(__s), _M_mark_count(0)
- { _M_compile(); }
-
- /**
- * @brief Constructs a basic regular expression from the range
- * [first, last) interpreted according to the flags in @p f.
- *
- * @param first The start of arange containing a valid regular
- * expression.
- * @param last The end of a range containing a valid regular
- * expression.
- * @param f The format flags of the regular expression.
- *
- * @throws regex_error if @p p is not a valid regular expression.
- */
- template<typename _InputIterator>
- basic_regex(_InputIterator __first, _InputIterator __last,
- flag_type __f = regex_constants::ECMAScript)
- : _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
- { _M_compile(); }
-
- /**
- * @brief Destroys a basic regular expression.
- */
- ~basic_regex()
- { }
-
- /**
- * @brief Assigns one regular expression to another.
- */
- basic_regex&
- operator=(const basic_regex& __rhs)
- { return this->assign(__rhs); }
-
- /**
- * @brief Replaces a regular expression with a new one constructed from
- * a C-style null-terminated string.
- *
- * @param A pointer to the start of a null-terminated C-style string
- * containing a regular expression.
- */
- basic_regex&
- operator=(const _Ch_type* __p)
- { return this->assign(__p, flags()); }
-
- /**
- * @brief Replaces a regular expression with a new one constructed from
- * a string.
- *
- * @param A pointer to a string containing a regular expression.
- */
- template<typename _Ch_typeraits, typename _Allocator>
- basic_regex&
- operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
- { return this->assign(__s, flags()); }
-
- // [7.8.3] assign
- /**
- * @brief the real assignment operator.
- *
- * @param that Another regular expression object.
- */
- basic_regex&
- assign(const basic_regex& __that)
- {
- basic_regex __tmp(__that);
- this->swap(__tmp);
- return *this;
- }
-
- /**
- * @brief Assigns a new regular expression to a regex object from a
- * C-style null-terminated string containing a regular expression
- * pattern.
- *
- * @param p A pointer to a C-style null-terminated string containing
- * a regular expression pattern.
- * @param flags Syntax option flags.
- *
- * @throws regex_error if p does not contain a valid regular expression
- * pattern interpreted according to @p flags. If regex_error is thrown,
- * *this remains unchanged.
- */
- basic_regex&
- assign(const _Ch_type* __p,
- flag_type __flags = regex_constants::ECMAScript)
- { return this->assign(string_type(__p), __flags); }
-
- /**
- * @brief Assigns a new regular expression to a regex object from a
- * C-style string containing a regular expression pattern.
- *
- * @param p A pointer to a C-style string containing a
- * regular expression pattern.
- * @param len The length of the regular expression pattern string.
- * @param flags Syntax option flags.
- *
- * @throws regex_error if p does not contain a valid regular expression
- * pattern interpreted according to @p flags. If regex_error is thrown,
- * *this remains unchanged.
- */
- basic_regex&
- assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
- { return this->assign(string_type(__p, __len), __flags); }
-
- /**
- * @brief Assigns a new regular expression to a regex object from a
- * string containing a regular expression pattern.
- *
- * @param s A string containing a regular expression pattern.
- * @param flags Syntax option flags.
- *
- * @throws regex_error if p does not contain a valid regular expression
- * pattern interpreted according to @p flags. If regex_error is thrown,
- * *this remains unchanged.
- */
- template<typename _Ch_typeraits, typename _Allocator>
- basic_regex&
- assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
- flag_type __f = regex_constants::ECMAScript)
- {
- basic_regex __tmp(__s, __f);
- this->swap(__tmp);
- return *this;
- }
-
- /**
- * @brief Assigns a new regular expression to a regex object.
- *
- * @param first The start of a range containing a valid regular
- * expression.
- * @param last The end of a range containing a valid regular
- * expression.
- * @param flags Syntax option flags.
- *
- * @throws regex_error if p does not contain a valid regular expression
- * pattern interpreted according to @p flags. If regex_error is thrown,
- * *this remains unchanged.
- */
- template<typename _InputIterator>
- basic_regex&
- assign(_InputIterator __first, _InputIterator __last,
- flag_type __flags = regex_constants::ECMAScript)
- { return this->assign(string_type(__first, __last), __flags); }
-
- // [7.8.4] const operations
- /**
- * @brief Gets the number of marked subexpressions within the regular
- * expresison.
- */
- unsigned int
- mark_count() const
- { return _M_mark_count; }
-
- /**
- * @brief Gets the flags used to construct the regular expression
- * or in the last call to assign().
- */
- flag_type
- flags() const
- { return _M_flags; }
-
- // [7.8.5] locale
- /**
- * @brief Imbues the regular expression object with the given locale.
- *
- * @param loc A locale.
- */
- locale_type
- imbue(locale_type __loc)
- { return _M_traits.imbue(__loc); }
-
- /**
- * @brief Gets the locale currently imbued in the regular expression
- * object.
- */
- locale_type
- getloc() const
- { return _M_traits.getloc(); }
-
- // [7.8.6] swap
- /**
- * @brief Swaps the contents of two regular expression obects.
- *
- * @param rhs Another regular expression object.
- */
- void
- swap(basic_regex& __rhs)
- {
- std::swap(_M_flags, __rhs._M_flags);
- std::swap(_M_pattern, __rhs._M_pattern);
- std::swap(_M_mark_count, __rhs._M_mark_count);
- std::swap(_M_traits, __rhs._M_traits);
- }
-
- private:
- /**
- * @brief Compiles a regular expression pattern into a NFA.
- * @todo Implement this function.
- */
- void _M_compile()
- { }
-
- protected:
- flag_type _M_flags;
- string_type _M_pattern;
- unsigned int _M_mark_count;
- _Rx_traits _M_traits;
- };
-
- typedef basic_regex<char> regex;
-#ifdef _GLIBCXX_USE_WCHAR_T
- typedef basic_regex<wchar_t> wregex;
-#endif
-
-
- // [7.8.6] basic_regex swap
- /**
- * @brief Swaps the contents of two regular expression objects.
- * @param lhs First regular expression.
- * @param rhs Second regular expression.
- */
- template<typename _Ch_type, typename _Rx_traits>
- inline void
- swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
- basic_regex<_Ch_type, _Rx_traits>& __rhs)
- { return __lhs.swap(__rhs); }
-
-
- // [7.9] Class template sub_match
- /**
- * A sequence of characters matched by a particular marked sub-expression.
- *
- * An object of this class is essentially a pair of iterators marking a
- * matched subexpression within a regular expression pattern match. Such
- * objects can be converted to and compared with std::basic_string objects
- * of a similar base character type as the pattern matched by the regular
- * expression.
- *
- * The iterators that make up the pair are the usual half-open interval
- * referencing the actual original pattern matched.
- */
- template<typename _BiIter>
- class sub_match : public std::pair<_BiIter, _BiIter>
- {
- public:
- typedef typename iterator_traits<_BiIter>::value_type value_type;
- typedef typename iterator_traits<_BiIter>::difference_type
- difference_type;
- typedef _BiIter iterator;
-
- public:
- bool matched;
-
- /**
- * Gets the length of the matching sequence.
- */
- difference_type
- length() const
- { return this->matched ? std::distance(this->first, this->second) : 0; }
-
- /**
- * @brief Gets the matching sequence as a string.
- *
- * @returns the matching sequence as a string.
- *
- * This is the implicit conversion operator. It is identical to the
- * str() member function except that it will want to pop up in
- * unexpected places and cause a great deal of confusion and cursing
- * from the unwary.
- */
- operator basic_string<value_type>() const
- {
- return this->matched
- ? std::basic_string<value_type>(this->first, this->second)
- : std::basic_string<value_type>();
- }
-
- /**
- * @brief Gets the matching sequence as a string.
- *
- * @returns the matching sequence as a string.
- */
- basic_string<value_type>
- str() const
- {
- return this->matched
- ? std::basic_string<value_type>(this->first, this->second)
- : std::basic_string<value_type>();
- }
-
- /**
- * @brief Compares this and another matched sequence.
- *
- * @param s Another matched sequence to compare to this one.
- *
- * @retval <0 this matched sequence will collate before @p s.
- * @retval =0 this matched sequence is equivalent to @p s.
- * @retval <0 this matched sequence will collate after @p s.
- */
- int
- compare(const sub_match& __s) const
- { return this->str().compare(__s.str()); }
-
- /**
- * @brief Compares this sub_match to a string.
- *
- * @param s A string to compare to this sub_match.
- *
- * @retval <0 this matched sequence will collate before @p s.
- * @retval =0 this matched sequence is equivalent to @p s.
- * @retval <0 this matched sequence will collate after @p s.
- */
- int
- compare(const basic_string<value_type>& __s) const
- { return this->str().compare(__s); }
-
- /**
- * @brief Compares this sub_match to a C-style string.
- *
- * @param s A C-style string to compare to this sub_match.
- *
- * @retval <0 this matched sequence will collate before @p s.
- * @retval =0 this matched sequence is equivalent to @p s.
- * @retval <0 this matched sequence will collate after @p s.
- */
- int
- compare(const value_type* __s) const
- { return this->str().compare(__s); }
- };
-
-
- typedef sub_match<const char*> csub_match;
- typedef sub_match<string::const_iterator> ssub_match;
-#ifdef _GLIBCXX_USE_WCHAR_T
- typedef sub_match<const wchar_t*> wcsub_match;
- typedef sub_match<wstring::const_iterator> wssub_match;
-#endif
-
- // [7.9.2] sub_match non-member operators
-
- /**
- * @brief Tests the equivalence of two regular expression submatches.
- * @param lhs First regular expression submatch.
- * @param rhs Second regular expression submatch.
- * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
- */
- template<typename _BiIter>
- inline bool
- operator==(const sub_match<_BiIter>& __lhs,
- const sub_match<_BiIter>& __rhs)
- { return __lhs.compare(__rhs) == 0; }
-
- /**
- * @brief Tests the inequivalence of two regular expression submatches.
- * @param lhs First regular expression submatch.
- * @param rhs Second regular expression submatch.
- * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
- */
- template<typename _BiIter>
- inline bool
- operator!=(const sub_match<_BiIter>& __lhs,
- const sub_match<_BiIter>& __rhs)
- { return __lhs.compare(__rhs) != 0; }
-
- /**
- * @brief Tests the ordering of two regular expression submatches.
- * @param lhs First regular expression submatch.
- * @param rhs Second regular expression submatch.
- * @returns true if @a lhs precedes @a rhs, false otherwise.
- */
- template<typename _BiIter>
- inline bool
- operator<(const sub_match<_BiIter>& __lhs,
- const sub_match<_BiIter>& __rhs)
- { return __lhs.compare(__rhs) < 0; }
-
- /**
- * @brief Tests the ordering of two regular expression submatches.
- * @param lhs First regular expression submatch.
- * @param rhs Second regular expression submatch.
- * @returns true if @a lhs does not succeed @a rhs, false otherwise.
- */
- template<typename _BiIter>
- inline bool
- operator<=(const sub_match<_BiIter>& __lhs,
- const sub_match<_BiIter>& __rhs)
- { return __lhs.compare(__rhs) <= 0; }
-
- /**
- * @brief Tests the ordering of two regular expression submatches.
- * @param lhs First regular expression submatch.
- * @param rhs Second regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
- */
- template<typename _BiIter>
- inline bool
- operator>=(const sub_match<_BiIter>& __lhs,
- const sub_match<_BiIter>& __rhs)
- { return __lhs.compare(__rhs) >= 0; }
-
- /**
- * @brief Tests the ordering of two regular expression submatches.
- * @param lhs First regular expression submatch.
- * @param rhs Second regular expression submatch.
- * @returns true if @a lhs succeeds @a rhs, false otherwise.
- */
- template<typename _BiIter>
- inline bool
- operator>(const sub_match<_BiIter>& __lhs,
- const sub_match<_BiIter>& __rhs)
- { return __lhs.compare(__rhs) > 0; }
-
- /**
- * @brief Tests the equivalence of a string and a regular expression
- * submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator==(const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs == __rhs.str(); }
-
- /**
- * @brief Tests the inequivalence of a string and a regular expression
- * submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator!=(const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
- { return __lhs != __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs precedes @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator<(const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
- { return __lhs < __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs succeeds @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator>(const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
- { return __lhs > __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator>=(const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
- { return __lhs >= __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs does not succeed @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator<=(const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
- { return __lhs <= __rhs.str(); }
-
- /**
- * @brief Tests the equivalence of a regular expression submatch and a
- * string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator==(const sub_match<_Bi_iter>& __lhs,
- const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __rhs)
- { return __lhs.str() == __rhs; }
-
- /**
- * @brief Tests the inequivalence of a regular expression submatch and a
- * string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
- inline bool
- operator!=(const sub_match<_Bi_iter>& __lhs,
- const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __rhs)
- { return __lhs.str() != __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs precedes @a rhs, false otherwise.
- */
- template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
- inline bool
- operator<(const sub_match<_Bi_iter>& __lhs,
- const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __rhs)
- { return __lhs.str() < __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs succeeds @a rhs, false otherwise.
- */
- template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
- inline bool
- operator>(const sub_match<_Bi_iter>& __lhs,
- const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __rhs)
- { return __lhs.str() > __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
- */
- template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
- inline bool
- operator>=(const sub_match<_Bi_iter>& __lhs,
- const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __rhs)
- { return __lhs.str() >= __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs does not succeed @a rhs, false otherwise.
- */
- template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
- inline bool
- operator<=(const sub_match<_Bi_iter>& __lhs,
- const basic_string<
- typename iterator_traits<_Bi_iter>::value_type,
- _Ch_traits, _Ch_alloc>& __rhs)
- { return __lhs.str() <= __rhs; }
-
- /**
- * @brief Tests the equivalence of a C string and a regular expression
- * submatch.
- * @param lhs A C string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs == __rhs.str(); }
-
- /**
- * @brief Tests the inequivalence of an iterator value and a regular
- * expression submatch.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs != __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs precedes @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs < __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs succeeds @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs > __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs >= __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs does not succeed @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs <= __rhs.str(); }
-
- /**
- * @brief Tests the equivalence of a regular expression submatch and a
- * string.
- * @param lhs A regular expression submatch.
- * @param rhs A pointer to a string?
- * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator==(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const* __rhs)
- { return __lhs.str() == __rhs; }
-
- /**
- * @brief Tests the inequivalence of a regular expression submatch and a
- * string.
- * @param lhs A regular expression submatch.
- * @param rhs A pointer to a string.
- * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator!=(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const* __rhs)
- { return __lhs.str() != __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs precedes @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const* __rhs)
- { return __lhs.str() < __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs succeeds @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const* __rhs)
- { return __lhs.str() > __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs does not precede @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>=(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const* __rhs)
- { return __lhs.str() >= __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A string.
- * @returns true if @a lhs does not succeed @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<=(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const* __rhs)
- { return __lhs.str() <= __rhs; }
-
- /**
- * @brief Tests the equivalence of a string and a regular expression
- * submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs == __rhs.str(); }
-
- /**
- * @brief Tests the inequivalence of a string and a regular expression
- * submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs != __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs precedes @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs < __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs succeeds @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs > __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs >= __rhs.str(); }
-
- /**
- * @brief Tests the ordering of a string and a regular expression submatch.
- * @param lhs A string.
- * @param rhs A regular expression submatch.
- * @returns true if @a lhs does not succeed @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
- const sub_match<_Bi_iter>& __rhs)
- { return __lhs <= __rhs.str(); }
-
- /**
- * @brief Tests the equivalence of a regular expression submatch and a
- * string.
- * @param lhs A regular expression submatch.
- * @param rhs A const string reference.
- * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator==(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const& __rhs)
- { return __lhs.str() == __rhs; }
-
- /**
- * @brief Tests the inequivalence of a regular expression submatch and a
- * string.
- * @param lhs A regular expression submatch.
- * @param rhs A const string reference.
- * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator!=(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const& __rhs)
- { return __lhs.str() != __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A const string reference.
- * @returns true if @a lhs preceeds @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const& __rhs)
- { return __lhs.str() < __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A const string reference.
- * @returns true if @a lhs succeeds @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const& __rhs)
- { return __lhs.str() > __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A const string reference.
- * @returns true if @a lhs does not preceed @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator>=(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const& __rhs)
- { return __lhs.str() >= __rhs; }
-
- /**
- * @brief Tests the ordering of a regular expression submatch and a string.
- * @param lhs A regular expression submatch.
- * @param rhs A const string reference.
- * @returns true if @a lhs does not succeed @a rhs, false otherwise.
- */
- template<typename _Bi_iter>
- inline bool
- operator<=(const sub_match<_Bi_iter>& __lhs,
- typename iterator_traits<_Bi_iter>::value_type const& __rhs)
- { return __lhs.str() <= __rhs; }
-
- /**
- * @brief Inserts a matched string into an output stream.
- *
- * @param os The output stream.
- * @param m A submatch string.
- *
- * @returns the output stream with the submatch string inserted.
- */
- template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
- inline
- basic_ostream<_Ch_type, _Ch_traits>&
- operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
- const sub_match<_Bi_iter>& __m)
- { return __os << __m.str(); }
-
- // [7.10] Class template match_results
- /**
- * A collection of character sequences representing the result of a regular
- * expression match. Storage for the collection is allocated and freed as
- * necessary by the member functions of class template match_results.
- *
- * This class satisfies the Sequence requirements, with the exception that
- * only the operations defined for a const-qualified Sequence are supported.
- *
- * The sub_match object stored at index 0 represents sub-expression 0, i.e.
- * the whole match. In this case the sub_match member matched is always true.
- * The sub_match object stored at index n denotes what matched the marked
- * sub-expression n within the matched expression. If the sub-expression n
- * participated in a regular expression match then the sub_match member
- * matched evaluates to true, and members first and second denote the range
- * of characters [first, second) which formed that match. Otherwise matched
- * is false, and members first and second point to the end of the sequence
- * that was searched.
- */
- template<typename _Bi_iter,
- typename _Allocator = allocator<sub_match<_Bi_iter> > >
- class match_results
- : private std::vector<std::_GLIBCXX_TR1::sub_match<_Bi_iter>, _Allocator>
- {
- private:
- typedef std::vector<std::_GLIBCXX_TR1::sub_match<_Bi_iter>, _Allocator>
- _Base_type;
-
- public:
- typedef sub_match<_Bi_iter> value_type;
- typedef typename _Allocator::const_reference const_reference;
- typedef const_reference reference;
- typedef typename _Base_type::const_iterator const_iterator;
- typedef const_iterator iterator;
- typedef typename iterator_traits<_Bi_iter>::difference_type
- difference_type;
- typedef typename _Allocator::size_type size_type;
- typedef _Allocator allocator_type;
- typedef typename iterator_traits<_Bi_iter>::value_type char_type;
- typedef basic_string<char_type> string_type;
-
- public:
- // [7.10.1] construct/copy/destroy
- /**
- * @brief Constructs a default match_results container.
- */
- explicit
- match_results(const _Allocator& __a = _Allocator())
- : _Base_type(__a), _M_matched(false)
- { }
-
- /**
- * @brief Copy constructs a match_result.
- */
- match_results(const match_results& __rhs)
- : _Base_type(__rhs), _M_matched(__rhs._M_matched),
- _M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
- { }
-
- /**
- * @brief Assigns rhs to *this.
- */
- match_results&
- operator=(const match_results& __rhs)
- {
- match_results __tmp(__rhs);
- this->swap(__tmp);
- }
-
- /**
- * @todo Implement this function.
- */
- ~match_results()
- { }
-
- // [7.10.2] size
- /**
- * @todo Document this function.
- */
- size_type
- size() const
- { return _M_matched ? _Base_type::size() + 1 : 0; }
-
- /**
- * @todo Implement this function.
- */
- //size_type
- //max_size() const;
- using _Base_type::max_size;
-
- /**
- * @todo Document this function.
- */
- bool
- empty() const
- { return size() == 0; }
-
- // [7.10.3] element access
- /**
- * @brief Gets the length of the indicated submatch.
- * @param sub indicates the submatch.
- */
- difference_type
- length(size_type __sub = 0) const
- { return _M_matched ? this->str(__sub).length() : 0; }
-
- /**
- * @todo Document this function.
- */
- difference_type
- position(size_type __sub = 0) const
- {
- return _M_matched ? std::distance(this->prefix().first,
- (*this)[__sub].first) : 0;
- }
-
- /**
- * @todo Document this function.
- */
- string_type
- str(size_type __sub = 0) const
- { return _M_matched ? (*this)[__sub].str() : string_type(); }
-
- /**
- * @todo Document this function.
- */
- const_reference
- operator[](size_type __n) const
- { return _Base_type::operator[](__n); }
-
- /**
- * @todo Document this function.
- */
- const_reference
- prefix() const
- { return _M_prefix; }
-
- /**
- * @todo Document this function.
- */
- const_reference
- suffix() const
- { return _M_suffix; }
-
- /**
- * @todo Document this function.
- */
- const_iterator
- begin() const
- { return _Base_type::begin(); }
-
- /**
- * @todo Document this function.
- */
- const_iterator
- end() const
- { return _Base_type::end(); }
-
- // [7.10.4] format
- /**
- * @todo Implement this function.
- */
- template<typename _Out_iter>
- _Out_iter
- format(_Out_iter __out, const string_type& __fmt,
- regex_constants::match_flag_type __flags
- = regex_constants::format_default) const
- { return __out; }
-
- /**
- * @todo Implement this function.
- */
- string_type
- format(const string_type& __fmt,
- regex_constants::match_flag_type __flags
- = regex_constants::format_default) const;
-
- // [7.10.5] allocator
- /**
- * @todo Document this function.
- */
- //allocator_type
- //get_allocator() const;
- using _Base_type::get_allocator;
-
- // [7.10.6] swap
- /**
- * @todo Document this function.
- */
- void
- swap(match_results& __that)
- {
- _Base_type::swap(__that);
- std::swap(_M_matched, __that._M_matched);
- std::swap(_M_prefix, __that._M_prefix);
- std::swap(_M_suffix, __that._M_suffix);
- }
-
- private:
- bool _M_matched;
- value_type _M_prefix;
- value_type _M_suffix;
- };
-
- typedef match_results<const char*> cmatch;
- typedef match_results<string::const_iterator> smatch;
-#ifdef _GLIBCXX_USE_WCHAR_T
- typedef match_results<const wchar_t*> wcmatch;
- typedef match_results<wstring::const_iterator> wsmatch;
-#endif
-
- // match_results comparisons
- /**
- * @todo Implement this function.
- */
- template<typename _Bi_iter, typename _Allocator>
- inline bool
- operator==(const match_results<_Bi_iter, _Allocator>& __m1,
- const match_results<_Bi_iter, _Allocator>& __m2);
-
- /**
- * @todo Implement this function.
- */
- template<typename _Bi_iter, class _Allocator>
- inline bool
- operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
- const match_results<_Bi_iter, _Allocator>& __m2);
-
- // [7.10.6] match_results swap
- /**
- * @brief Swaps two match results.
- * @param lhs A match result.
- * @param rhs A match result.
- *
- * The contents of the two match_results objects are swapped.
- */
- template<typename _Bi_iter, typename _Allocator>
- inline void
- swap(match_results<_Bi_iter, _Allocator>& __lhs,
- match_results<_Bi_iter, _Allocator>& __rhs)
- { return __lhs.swap(__rhs); }
-
- // [7.11.2] Function template regex_match
- /**
- * @brief Determines if there is a match between the regular expression @p e
- * and all of the character sequence [first, last).
- *
- * @param first Beginning of the character sequence to match.
- * @param last One-past-the-end of the character sequence to match.
- * @param m The match results.
- * @param re The regular expression.
- * @param flags Controls how the regular expression is matched.
- *
- * @retval true A match exists.
- * @retval false Otherwise.
- *
- * @todo Implement this function.
- */
- template<typename _Bi_iter, typename _Allocator,
- typename _Ch_type, typename _Rx_traits>
- bool
- regex_match(_Bi_iter __first, _Bi_iter __last,
- match_results<_Bi_iter, _Allocator>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- { return false; }
-
- /**
- * @brief Indicates if there is a match between the regular expression @p e
- * and all of the character sequence [first, last).
- *
- * @param first Beginning of the character sequence to match.
- * @param last One-past-the-end of the character sequence to match.
- * @param re The regular expression.
- * @param flags Controls how the regular expression is matched.
- *
- * @retval true A match exists.
- * @retval false Otherwise.
- */
- template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
- bool
- regex_match(_Bi_iter __first, _Bi_iter __last,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- {
- match_results<_Bi_iter> __what;
- return regex_match(__first, __last, __what, __re, __flags);
- }
-
- /**
- * @brief Determines if there is a match between the regular expression @p e
- * and a C-style null-terminated string.
- *
- * @param s The C-style null-terminated string to match.
- * @param m The match results.
- * @param re The regular expression.
- * @param f Controls how the regular expression is matched.
- *
- * @retval true A match exists.
- * @retval false Otherwise.
- */
- template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
- inline bool
- regex_match(const _Ch_type* __s,
- match_results<const _Ch_type*, _Allocator>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __f
- = regex_constants::match_default)
- { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
-
- /**
- * @brief Determines if there is a match between the regular expression @p e
- * and a string.
- *
- * @param s The string to match.
- * @param m The match results.
- * @param re The regular expression.
- * @param flags Controls how the regular expression is matched.
- *
- * @retval true A match exists.
- * @retval false Otherwise.
- */
- template<typename _Ch_traits, typename _Ch_alloc,
- typename _Allocator, typename _Ch_type, typename _Rx_traits>
- inline bool
- regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
- match_results<typename basic_string<_Ch_type,
- _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
-
- /**
- * @brief Indicates if there is a match between the regular expression @p e
- * and a C-style null-terminated string.
- *
- * @param s The C-style null-terminated string to match.
- * @param re The regular expression.
- * @param f Controls how the regular expression is matched.
- *
- * @retval true A match exists.
- * @retval false Otherwise.
- */
- template<typename _Ch_type, class _Rx_traits>
- inline bool
- regex_match(const _Ch_type* __s,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __f
- = regex_constants::match_default)
- { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
-
- /**
- * @brief Indicates if there is a match between the regular expression @p e
- * and a string.
- *
- * @param s [IN] The string to match.
- * @param re [IN] The regular expression.
- * @param flags [IN] Controls how the regular expression is matched.
- *
- * @retval true A match exists.
- * @retval false Otherwise.
- */
- template<typename _Ch_traits, typename _Str_allocator,
- typename _Ch_type, typename _Rx_traits>
- inline bool
- regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- { return regex_match(__s.begin(), __s.end(), __re, __flags); }
-
- // [7.11.3] Function template regex_search
- /**
- * Searches for a regular expression within a range.
- * @param first [IN] The start of the string to search.
- * @param last [IN] One-past-the-end of the string to search.
- * @param m [OUT] The match results.
- * @param re [IN] The regular expression to search for.
- * @param flags [IN] Search policy flags.
- * @retval true A match was found within the string.
- * @retval false No match was found within the string, the content of %m is
- * undefined.
- * @todo Implement this function.
- */
- template<typename _Bi_iter, typename _Allocator,
- typename _Ch_type, typename _Rx_traits>
- inline bool
- regex_search(_Bi_iter __first, _Bi_iter __last,
- match_results<_Bi_iter, _Allocator>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- { return false; }
-
- /**
- * Searches for a regular expression within a range.
- * @param first [IN] The start of the string to search.
- * @param last [IN] One-past-the-end of the string to search.
- * @param re [IN] The regular expression to search for.
- * @param flags [IN] Search policy flags.
- * @retval true A match was found within the string.
- * @retval false No match was found within the string.
- * @todo Document me.
- */
- template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
- inline bool
- regex_search(_Bi_iter __first, _Bi_iter __last,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- {
- match_results<_Bi_iter> __what;
- return regex_search(__first, __last, __what, __re, __flags);
- }
-
- /**
- * @brief Searches for a regular expression within a C-string.
- * @param s [IN] A C-string to search for the regex.
- * @param m [OUT] The set of regex mnatches.
- * @param e [IN] The regex to search for in @p s.
- * @param f [IN] The search flags.
- * @retval true A match was found within the string.
- * @retval false No match was found within the string, the content of %m is
- * undefined.
- * @todo Document me.
- */
- template<typename _Ch_type, class _Allocator, class _Rx_traits>
- inline bool
- regex_search(const _Ch_type* __s,
- match_results<const _Ch_type*, _Allocator>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __e,
- regex_constants::match_flag_type __f
- = regex_constants::match_default)
- { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
-
- /**
- * @brief Searches for a regular expression within a C-string.
- * @param s [IN] The C-string to search.
- * @param e [IN] The regular expressioon to search for.
- * @param f [IN] Search policy flags.
- * @retval true A match was found within the string.
- * @retval false No match was found within the string.
- * @todo Document me.
- */
- template<typename _Ch_type, typename _Rx_traits>
- inline bool
- regex_search(const _Ch_type* __s,
- const basic_regex<_Ch_type, _Rx_traits>& __e,
- regex_constants::match_flag_type __f
- = regex_constants::match_default)
- { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
-
- /**
- * @brief Searches for a regular expression within a string.
- * @param s [IN] The string to search.
- * @param e [IN] The regular expressioon to search for.
- * @param flags [IN] Search policy flags.
- * @retval true A match was found within the string.
- * @retval false No match was found within the string.
- * @todo Document me.
- */
- template<typename _Ch_traits, typename _String_allocator,
- typename _Ch_type, typename _Rx_traits>
- inline bool
- regex_search(const basic_string<_Ch_type, _Ch_traits,
- _String_allocator>& __s,
- const basic_regex<_Ch_type, _Rx_traits>& __e,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- { return regex_search(__s.begin(), __s.end(), __e, __flags); }
-
- /**
- * @brief Searches for a regular expression within a string.
- * @param s [IN] A C++ string to search for the regex.
- * @param m [OUT] The set of regex mnatches.
- * @param e [IN] The regex to search for in @p s.
- * @param f [IN] The search flags.
- * @retval true A match was found within the string.
- * @retval false No match was found within the string, the content of %m is
- * undefined.
- */
- template<typename _Ch_traits, typename _Ch_alloc,
- typename _Allocator, typename _Ch_type,
- typename _Rx_traits>
- inline bool
- regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
- match_results<typename basic_string<_Ch_type,
- _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __e,
- regex_constants::match_flag_type __f
- = regex_constants::match_default)
- { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
-
- // [7.11.4] Function template regex_replace
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- template<typename _Out_iter, typename _Bi_iter,
- typename _Rx_traits, typename _Ch_type>
- inline _Out_iter
- regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
- const basic_regex<_Ch_type, _Rx_traits>& __e,
- const basic_string<_Ch_type>& __fmt,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- { return __out; }
-
- /**
- * @todo Document me.
- */
- template<typename _Rx_traits, typename _Ch_type>
- inline basic_string<_Ch_type>
- regex_replace(const basic_string<_Ch_type>& __s,
- const basic_regex<_Ch_type, _Rx_traits>& __e,
- const basic_string<_Ch_type>& __fmt,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- {
- std::string __result;
- regex_replace(std::back_inserter(__result),
- __s.begin(), __s.end(), __e, __fmt, __flags);
- return __result;
- }
-
- // [7.12.1] Class template regex_iterator
- /**
- * An iterator adaptor that will provide repeated calls of regex_search over
- * a range until no more matches remain.
- */
- template<typename _Bi_iter,
- typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
- typename _Rx_traits = regex_traits<_Ch_type> >
- class regex_iterator
- {
- public:
- typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
- typedef match_results<_Bi_iter> value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type* pointer;
- typedef const value_type& reference;
- typedef std::forward_iterator_tag iterator_category;
-
- public:
- /**
- * @brief Provides a singular iterator, useful for indicating
- * one-past-the-end of a range.
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_iterator();
-
- /**
- * Constructs a %regex_iterator...
- * @param a [IN] The start of a text range to search.
- * @param b [IN] One-past-the-end of the text range to search.
- * @param re [IN] The regular expression to match.
- * @param m [IN] Policy flags for match rules.
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
- regex_constants::match_flag_type __m
- = regex_constants::match_default);
-
- /**
- * Copy constructs a %regex_iterator.
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_iterator(const regex_iterator& __rhs);
-
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_iterator&
- operator=(const regex_iterator& __rhs);
-
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- bool
- operator==(const regex_iterator& __rhs);
-
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- bool
- operator!=(const regex_iterator& __rhs);
-
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- const value_type&
- operator*();
-
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- const value_type*
- operator->();
-
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_iterator&
- operator++();
-
- /**
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_iterator
- operator++(int);
-
- private:
- // these members are shown for exposition only:
- _Bi_iter begin;
- _Bi_iter end;
- const regex_type* pregex;
- regex_constants::match_flag_type flags;
- match_results<_Bi_iter> match;
- };
-
- typedef regex_iterator<const char*> cregex_iterator;
- typedef regex_iterator<string::const_iterator> sregex_iterator;
-#ifdef _GLIBCXX_USE_WCHAR_T
- typedef regex_iterator<const wchar_t*> wcregex_iterator;
- typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
-#endif
-
- // [7.12.2] Class template regex_token_iterator
- /**
- * Iterates over submatches in a range (or "splits" a text string).
- *
- * The purpose of this iterator is to enumerate all, or all specified,
- * matches of a regular expression within a text range. The dereferenced
- * value of an iterator of this class is a std::tr1::sub_match object.
- */
- template<typename _Bi_iter,
- typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
- typename _Rx_traits = regex_traits<_Ch_type> >
- class regex_token_iterator
- {
- public:
- typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
- typedef sub_match<_Bi_iter> value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type* pointer;
- typedef const value_type& reference;
- typedef std::forward_iterator_tag iterator_category;
-
- public:
- /**
- * @brief Default constructs a %regex_token_iterator.
- * @todo Implement this function.
- *
- * A default-constructed %regex_token_iterator is a singular iterator
- * that will compare equal to the one-past-the-end value for any
- * iterator of the same type.
- */
- regex_token_iterator();
-
- /**
- * Constrcts a %regex_token_iterator...
- * @param a [IN] The start of the text to search.
- * @param b [IN] One-past-the-eend of the text to search.
- * @param re [IN] The regular expression to search for.
- * @param submatch [IN] Which submatch to return. There are some
- * special values for thsi parameter:
- * - -1 each enumerated subexpression does NOT
- * match the regular expression (aka field
- * splitting)
- * - 0 the entire string matching the
- * subexpression is returned for each match
- * within the text.
- * - >0 enumerates only the indicated
- * subexpression from a match within the text.
- * @param m [IN] Policy flags for match rules.
- *
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
- int __submatch = 0,
- regex_constants::match_flag_type __m
- = regex_constants::match_default);
-
- /**
- * Constrcts a %regex_token_iterator...
- * @param a [IN] The start of the text to search.
- * @param b [IN] One-past-the-eend of the text to search.
- * @param re [IN] The regular expression to search for.
- * @param submatches [IN] A list of subexpressions to return for each
- * regular expression match within the text.
- * @param m [IN] Policy flags for match rules.
- *
- * @todo Implement this function.
- * @todo Document this function.
- */
- regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
- const regex_type& __re,
- const std::vector<int>& __submatches,
- regex_constants::match_flag_type __m
- = regex_constants::match_default);
-
- /**
- * Constrcts a %regex_token_iterator...
- * @param a [IN] The start of the text to search.
- * @param b [IN] One-past-the-eend of the text to search.
- * @param re [IN] The regular expression to search for.
- * @param submatches [IN] A list of subexpressions to return for each
- * regular expression match within the text.
- * @param m [IN] Policy flags for match rules.
-
- * @todo Implement this function.
- * @todo Document this function.
- */
- template<std::size_t _Nm>
- regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
- const regex_type& __re,
- const int (&__submatches)[_Nm],
- regex_constants::match_flag_type __m
- = regex_constants::match_default);
-
- /**
- * @brief Copy constructs a %regex_token_iterator.
- * @param rhs [IN] A %regex_token_iterator to copy.
- * @todo Implement this function.
- */
- regex_token_iterator(const regex_token_iterator& __rhs);
-
- /**
- * @brief Assigns a %regex_token_iterator to another.
- * @param rhs [IN] A %regex_token_iterator to copy.
- * @todo Implement this function.
- */
- regex_token_iterator&
- operator=(const regex_token_iterator& __rhs);
-
- /**
- * @brief Compares a %regex_token_iterator to another for equality.
- * @todo Implement this function.
- */
- bool
- operator==(const regex_token_iterator& __rhs);
-
- /**
- * @brief Compares a %regex_token_iterator to another for inequality.
- * @todo Implement this function.
- */
- bool
- operator!=(const regex_token_iterator& __rhs);
-
- /**
- * @brief Dereferences a %regex_token_iterator.
- * @todo Implement this function.
- */
- const value_type&
- operator*();
-
- /**
- * @brief Selects a %regex_token_iterator member.
- * @todo Implement this function.
- */
- const value_type*
- operator->();
-
- /**
- * @brief Increments a %regex_token_iterator.
- * @todo Implement this function.
- */
- regex_token_iterator&
- operator++();
-
- /**
- * @brief Postincrements a %regex_token_iterator.
- * @todo Implement this function.
- */
- regex_token_iterator
- operator++(int);
-
- private: // data members for exposition only:
- typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
-
- position_iterator __position;
- const value_type* __result;
- value_type __suffix;
- std::size_t __n;
- std::vector<int> __subs;
- };
-
- typedef regex_token_iterator<const char*> cregex_token_iterator;
- typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
-#ifdef _GLIBCXX_USE_WCHAR_T
- typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
- typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/regex>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/regex>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
-
- /** @} */ // group tr1_regex
-
-_GLIBCXX_END_NAMESPACE
-}
-#endif // _TR1_REGEX
+#endif // _GLIBCXX_TR1_REGEX
// (3) Gamma, Exploring Euler's Constant, Julian Havil,
// Princeton, 2003.
-#ifndef _TR1_RIEMANN_ZETA_TCC
-#define _TR1_RIEMANN_ZETA_TCC 1
+#ifndef _GLIBCXX_TR1_RIEMANN_ZETA_TCC
+#define _GLIBCXX_TR1_RIEMANN_ZETA_TCC 1
#include "special_function_util.h"
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
// [5.2] Special functions
if (__s < _Tp(0))
{
#if _GLIBCXX_USE_C99_MATH_TR1
- if (std::_GLIBCXX_TR1::fmod(__s,_Tp(2)) == _Tp(0))
+ if (std::tr1::fmod(__s,_Tp(2)) == _Tp(0))
return _Tp(0);
else
#endif
* __numeric_constants<_Tp>::__pi(), __s)
* std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
#if _GLIBCXX_USE_C99_MATH_TR1
- * std::exp(std::_GLIBCXX_TR1::lgamma(_Tp(1) - __s))
+ * std::exp(std::tr1::lgamma(_Tp(1) - __s))
#else
* std::exp(__log_gamma(_Tp(1) - __s))
#endif
for (unsigned int __j = 0; __j <= __i; ++__j)
{
#if _GLIBCXX_USE_C99_MATH_TR1
- _Tp __bincoeff = std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i))
- - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __j))
- - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i - __j));
+ _Tp __bincoeff = std::tr1::lgamma(_Tp(1 + __i))
+ - std::tr1::lgamma(_Tp(1 + __j))
+ - std::tr1::lgamma(_Tp(1 + __i - __j));
#else
_Tp __bincoeff = __log_gamma(_Tp(1 + __i))
- __log_gamma(_Tp(1 + __j))
__zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
* std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
#if _GLIBCXX_USE_C99_MATH_TR1
- * std::exp(std::_GLIBCXX_TR1::lgamma(_Tp(1) - __s))
+ * std::exp(std::tr1::lgamma(_Tp(1) - __s))
#else
* std::exp(__log_gamma(_Tp(1) - __s))
#endif
* __numeric_constants<_Tp>::__pi(), __s)
* std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
#if _GLIBCXX_USE_C99_MATH_TR1
- * std::_GLIBCXX_TR1::tgamma(_Tp(1) - __s)
+ * std::tr1::tgamma(_Tp(1) - __s)
#else
* std::exp(__log_gamma(_Tp(1) - __s))
#endif
for (unsigned int __j = 0; __j <= __i; ++__j)
{
#if _GLIBCXX_USE_C99_MATH_TR1
- _Tp __bincoeff = std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i))
- - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __j))
- - std::_GLIBCXX_TR1::lgamma(_Tp(1 + __i - __j));
+ _Tp __bincoeff = std::tr1::lgamma(_Tp(1 + __i))
+ - std::tr1::lgamma(_Tp(1 + __j))
+ - std::tr1::lgamma(_Tp(1 + __i - __j));
#else
_Tp __bincoeff = __log_gamma(_Tp(1 + __i))
- __log_gamma(_Tp(1 + __j))
/* @} */ // group tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_RIEMANN_ZETA_TCC
+#endif // _GLIBCXX_TR1_RIEMANN_ZETA_TCC
// Written by Edward Smith-Rowland based on numerous mathematics books.
-#ifndef _TR1_SPECIAL_FUNCTION_UTIL_H
-#define _TR1_SPECIAL_FUNCTION_UTIL_H 1
+#ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
+#define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
// namespace std::tr1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+namespace tr1
+{
namespace __detail
{
} // namespace __detail
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif // _TR1_SPECIAL_FUNCTION_UTIL_H
+#endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_STDLIB_H
-#define _TR1_STDLIB_H 1
+#ifndef _GLIBCXX_TR1_STDLIB_H
+#define _GLIBCXX_TR1_STDLIB_H 1
#include <tr1/cstdlib>
#if _GLIBCXX_USE_C99
-using std::_GLIBCXX_TR1::atoll;
-using std::_GLIBCXX_TR1::strtoll;
-using std::_GLIBCXX_TR1::strtoull;
+using std::tr1::atoll;
+using std::tr1::strtoll;
+using std::tr1::strtoull;
-using std::_GLIBCXX_TR1::abs;
+using std::tr1::abs;
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
-using std::_GLIBCXX_TR1::div;
+using std::tr1::div;
#endif
#endif
#endif
-#endif
+#endif // _GLIBCXX_TR1_STDLIB_H
+
// TR1 tgmath.h -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_TGMATH_H
-#define _TR1_TGMATH_H 1
+#ifndef _GLIBCXX_TR1_TGMATH_H
+#define _GLIBCXX_TR1_TGMATH_H 1
#include <tr1/ctgmath>
-#endif
+#endif // _GLIBCXX_TR1_TGMATH_H
// Chris Jefferson <chris@bubblescope.net>
// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
-#ifndef _TR1_TUPLE
-#define _TR1_TUPLE 1
+#ifndef _GLIBCXX_TR1_TUPLE
+#define _GLIBCXX_TR1_TUPLE 1
#pragma GCC system_header
-#include <utility>
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- template<typename _Tp>
- class reference_wrapper;
-
- // Adds a const reference to a non-reference type.
- template<typename _Tp>
- struct __add_c_ref
- { typedef const _Tp& type; };
-
- template<typename _Tp>
- struct __add_c_ref<_Tp&>
- { typedef _Tp& type; };
-
- // Adds a reference to a non-reference type.
- template<typename _Tp>
- struct __add_ref
- { typedef _Tp& type; };
-
- template<typename _Tp>
- struct __add_ref<_Tp&>
- { typedef _Tp& type; };
-
- /**
- * @if maint
- * Contains the actual implementation of the @c tuple template, stored
- * as a recursive inheritance hierarchy from the first element (most
- * derived class) to the last (least derived class). The @c Idx
- * parameter gives the 0-based index of the element stored at this
- * point in the hierarchy; we use it to implement a constant-time
- * get() operation.
- * @endif
- */
- template<int _Idx, typename... _Elements>
- struct _Tuple_impl;
-
- /**
- * @if maint
- * Zero-element tuple implementation. This is the basis case for the
- * inheritance recursion.
- * @endif maint
- */
- template<int _Idx>
- struct _Tuple_impl<_Idx> { };
-
- /**
- * @if maint
- * Recursive tuple implementation. Here we store the @c Head element
- * and derive from a @c Tuple_impl containing the remaining elements
- * (which contains the @c Tail).
- * @endif
- */
- template<int _Idx, typename _Head, typename... _Tail>
- struct _Tuple_impl<_Idx, _Head, _Tail...>
- : public _Tuple_impl<_Idx + 1, _Tail...>
- {
- typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
-
- _Head _M_head;
-
- _Inherited& _M_tail() { return *this; }
- const _Inherited& _M_tail() const { return *this; }
-
- _Tuple_impl() : _Inherited(), _M_head() { }
-
- explicit
- _Tuple_impl(typename __add_c_ref<_Head>::type __head,
- typename __add_c_ref<_Tail>::type... __tail)
- : _Inherited(__tail...), _M_head(__head) { }
-
- template<typename... _UElements>
- _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
- : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
-
- _Tuple_impl(const _Tuple_impl& __in)
- : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
-
- template<typename... _UElements>
- _Tuple_impl&
- operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
- {
- _M_head = __in._M_head;
- _M_tail() = __in._M_tail();
- return *this;
- }
-
- _Tuple_impl&
- operator=(const _Tuple_impl& __in)
- {
- _M_head = __in._M_head;
- _M_tail() = __in._M_tail();
- return *this;
- }
- };
-
- template<typename... _Elements>
- class tuple : public _Tuple_impl<0, _Elements...>
- {
- typedef _Tuple_impl<0, _Elements...> _Inherited;
-
- public:
- tuple() : _Inherited() { }
-
- explicit
- tuple(typename __add_c_ref<_Elements>::type... __elements)
- : _Inherited(__elements...) { }
-
- template<typename... _UElements>
- tuple(const tuple<_UElements...>& __in)
- : _Inherited(__in) { }
-
- tuple(const tuple& __in)
- : _Inherited(__in) { }
-
- template<typename... _UElements>
- tuple&
- operator=(const tuple<_UElements...>& __in)
- {
- static_cast<_Inherited&>(*this) = __in;
- return *this;
- }
-
- tuple&
- operator=(const tuple& __in)
- {
- static_cast<_Inherited&>(*this) = __in;
- return *this;
- }
- };
-
- template<> class tuple<> { };
-
- // 2-element tuple, with construction and assignment from a pair.
- template<typename _T1, typename _T2>
- class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
- {
- typedef _Tuple_impl<0, _T1, _T2> _Inherited;
-
- public:
- tuple() : _Inherited() { }
-
- explicit
- tuple(typename __add_c_ref<_T1>::type __a1,
- typename __add_c_ref<_T2>::type __a2)
- : _Inherited(__a1, __a2) { }
-
- template<typename _U1, typename _U2>
- tuple(const tuple<_U1, _U2>& __in)
- : _Inherited(__in) { }
-
- tuple(const tuple& __in)
- : _Inherited(__in) { }
-
- template<typename _U1, typename _U2>
- tuple(const pair<_U1, _U2>& __in)
- : _Inherited(_Tuple_impl<0,
- typename __add_c_ref<_U1>::type,
- typename __add_c_ref<_U2>::type>(__in.first,
- __in.second))
- { }
-
- template<typename _U1, typename _U2>
- tuple&
- operator=(const tuple<_U1, _U2>& __in)
- {
- static_cast<_Inherited&>(*this) = __in;
- return *this;
- }
-
- tuple&
- operator=(const tuple& __in)
- {
- static_cast<_Inherited&>(*this) = __in;
- return *this;
- }
-
- template<typename _U1, typename _U2>
- tuple&
- operator=(const pair<_U1, _U2>& __in)
- {
- this->_M_head = __in.first;
- this->_M_tail()._M_head = __in.second;
- return *this;
- }
- };
-
-
- /// Gives the type of the ith element of a given tuple type.
- template<int __i, typename _Tp>
- struct tuple_element;
-
- /**
- * @if maint
- * Recursive case for tuple_element: strip off the first element in
- * the tuple and retrieve the (i-1)th element of the remaining tuple.
- * @endif
- */
- template<int __i, typename _Head, typename... _Tail>
- struct tuple_element<__i, tuple<_Head, _Tail...> >
- : tuple_element<__i - 1, tuple<_Tail...> > { };
-
- /**
- * @if maint
- * Basis case for tuple_element: The first element is the one we're seeking.
- * @endif
- */
- template<typename _Head, typename... _Tail>
- struct tuple_element<0, tuple<_Head, _Tail...> >
- {
- typedef _Head type;
- };
-
- /// Finds the size of a given tuple type.
- template<typename _Tp>
- struct tuple_size;
-
- /// @brief class tuple_size
- template<typename... _Elements>
- struct tuple_size<tuple<_Elements...> >
- {
- static const int value = sizeof...(_Elements);
- };
-
- template<typename... _Elements>
- const int tuple_size<tuple<_Elements...> >::value;
-
- template<int __i, typename _Head, typename... _Tail>
- inline typename __add_ref<_Head>::type
- __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
- {
- return __t._M_head;
- }
-
- template<int __i, typename _Head, typename... _Tail>
- inline typename __add_c_ref<_Head>::type
- __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
- {
- return __t._M_head;
- }
-
- // Return a reference (const reference) to the ith element of a tuple.
- // Any const or non-const ref elements are returned with their original type.
- template<int __i, typename... _Elements>
- inline typename __add_ref<
- typename tuple_element<__i, tuple<_Elements...> >::type
- >::type
- get(tuple<_Elements...>& __t)
- {
- return __get_helper<__i>(__t);
- }
-
- template<int __i, typename... _Elements>
- inline typename __add_c_ref<
- typename tuple_element<__i, tuple<_Elements...> >::type
- >::type
- get(const tuple<_Elements...>& __t)
- {
- return __get_helper<__i>(__t);
- }
-
- // This class helps construct the various comparison operations on tuples
- template<int __check_equal_size, int __i, int __j,
- typename _Tp, typename _Up>
- struct __tuple_compare;
-
- template<int __i, int __j, typename _Tp, typename _Up>
- struct __tuple_compare<0, __i, __j, _Tp, _Up>
- {
- static bool __eq(const _Tp& __t, const _Up& __u)
- {
- return (get<__i>(__t) == get<__i>(__u) &&
- __tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
- }
-
- static bool __less(const _Tp& __t, const _Up& __u)
- {
- return ((get<__i>(__t) < get<__i>(__u))
- || !(get<__i>(__u) < get<__i>(__t)) &&
- __tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
- }
- };
-
- template<int __i, typename _Tp, typename _Up>
- struct __tuple_compare<0, __i, __i, _Tp, _Up>
- {
- static bool __eq(const _Tp&, const _Up&)
- { return true; }
-
- static bool __less(const _Tp&, const _Up&)
- { return false; }
- };
-
- template<typename... _TElements, typename... _UElements>
- bool
- operator==(const tuple<_TElements...>& __t,
- const tuple<_UElements...>& __u)
- {
- typedef tuple<_TElements...> _Tp;
- typedef tuple<_UElements...> _Up;
- return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
- 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
- }
-
- template<typename... _TElements, typename... _UElements>
- bool
- operator<(const tuple<_TElements...>& __t,
- const tuple<_UElements...>& __u)
- {
- typedef tuple<_TElements...> _Tp;
- typedef tuple<_UElements...> _Up;
- return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
- 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
- }
-
- template<typename... _TElements, typename... _UElements>
- bool
- operator!=(const tuple<_TElements...>& __t,
- const tuple<_UElements...>& __u)
- { return !(__t == __u); }
-
- template<typename... _TElements, typename... _UElements>
- bool
- operator>(const tuple<_TElements...>& __t,
- const tuple<_UElements...>& __u)
- { return __u < __t; }
-
- template<typename... _TElements, typename... _UElements>
- bool
- operator<=(const tuple<_TElements...>& __t,
- const tuple<_UElements...>& __u)
- { return !(__u < __t); }
-
- template<typename... _TElements, typename... _UElements>
- bool
- operator>=(const tuple<_TElements...>& __t,
- const tuple<_UElements...>& __u)
- { return !(__t < __u); }
-
- // Helper which adds a reference to a type when given a reference_wrapper
- template<typename _Tp>
- struct __strip_reference_wrapper
- {
- typedef _Tp __type;
- };
-
- template<typename _Tp>
- struct __strip_reference_wrapper<reference_wrapper<_Tp> >
- {
- typedef _Tp& __type;
- };
-
- template<typename _Tp>
- struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
- {
- typedef _Tp& __type;
- };
-
- template<typename... _Elements>
- inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
- make_tuple(_Elements... __args)
- {
- typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
- __result_type;
- return __result_type(__args...);
- }
-
- template<typename... _Elements>
- inline tuple<_Elements&...>
- tie(_Elements&... __args)
- {
- return tuple<_Elements&...>(__args...);
- }
-
- // A class (and instance) which can be used in 'tie' when an element
- // of a tuple is not required
- struct _Swallow_assign
- {
- template<class _Tp>
- _Swallow_assign&
- operator=(const _Tp&)
- { return *this; }
- };
-
- // TODO: Put this in some kind of shared file.
- namespace
- {
- _Swallow_assign ignore;
- }; // anonymous namespace
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
-_GLIBCXX_END_NAMESPACE
-}
+#include <utility>
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/tuple>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/tuple>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
+
+#endif // _GLIBCXX_TR1_TUPLE
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_TYPE_TRAITS
-#define _TR1_TYPE_TRAITS 1
+#ifndef _GLIBCXX_TR1_TYPE_TRAITS
+#define _GLIBCXX_TR1_TYPE_TRAITS 1
#pragma GCC system_header
-#include <bits/c++config.h>
-#include <tr1/type_traitsfwd.h>
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cstddef>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/type_traits>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/type_traits>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
-// namespace std::tr1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // For use in __is_convertible_simple.
- struct __sfinae_types
- {
- typedef char __one;
- typedef struct { char __arr[2]; } __two;
- };
-
+namespace tr1
+{
#define _DEFINE_SPEC_BODY(_Value) \
: public integral_constant<bool, _Value> { };
struct _Spec \
_DEFINE_SPEC_BODY(_Value)
-#define _DEFINE_SPEC_1_HELPER(_Spec, _Value) \
- template<typename _Tp> \
- struct _Spec \
- _DEFINE_SPEC_BODY(_Value)
-
-#define _DEFINE_SPEC_2_HELPER(_Spec, _Value) \
- template<typename _Tp, typename _Cp> \
- struct _Spec \
- _DEFINE_SPEC_BODY(_Value)
-
#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value) \
_DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type>, _Value) \
_DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const>, _Value) \
_DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type volatile>, _Value) \
_DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const volatile>, _Value)
- /// @brief helper classes [4.3].
- template<typename _Tp, _Tp __v>
- struct integral_constant
- {
- static const _Tp value = __v;
- typedef _Tp value_type;
- typedef integral_constant<_Tp, __v> type;
- };
- typedef integral_constant<bool, true> true_type;
- typedef integral_constant<bool, false> false_type;
-
- template<typename _Tp, _Tp __v>
- const _Tp integral_constant<_Tp, __v>::value;
-
- /// @brief primary type categories [4.5.1].
template<typename>
- struct is_void
- : public false_type { };
- _DEFINE_SPEC(0, is_void, void, true)
-
- template<typename>
- struct is_integral
- : public false_type { };
- _DEFINE_SPEC(0, is_integral, bool, true)
- _DEFINE_SPEC(0, is_integral, char, true)
- _DEFINE_SPEC(0, is_integral, signed char, true)
- _DEFINE_SPEC(0, is_integral, unsigned char, true)
-#ifdef _GLIBCXX_USE_WCHAR_T
- _DEFINE_SPEC(0, is_integral, wchar_t, true)
-#endif
- _DEFINE_SPEC(0, is_integral, short, true)
- _DEFINE_SPEC(0, is_integral, unsigned short, true)
- _DEFINE_SPEC(0, is_integral, int, true)
- _DEFINE_SPEC(0, is_integral, unsigned int, true)
- _DEFINE_SPEC(0, is_integral, long, true)
- _DEFINE_SPEC(0, is_integral, unsigned long, true)
- _DEFINE_SPEC(0, is_integral, long long, true)
- _DEFINE_SPEC(0, is_integral, unsigned long long, true)
-
- template<typename>
- struct is_floating_point
- : public false_type { };
- _DEFINE_SPEC(0, is_floating_point, float, true)
- _DEFINE_SPEC(0, is_floating_point, double, true)
- _DEFINE_SPEC(0, is_floating_point, long double, true)
-
- template<typename>
- struct is_array
- : public false_type { };
-
- template<typename _Tp, std::size_t _Size>
- struct is_array<_Tp[_Size]>
- : public true_type { };
-
- template<typename _Tp>
- struct is_array<_Tp[]>
- : public true_type { };
-
- template<typename>
- struct is_pointer
- : public false_type { };
- _DEFINE_SPEC(1, is_pointer, _Tp*, true)
-
- template<typename>
- struct is_reference
- : public false_type { };
-
- template<typename _Tp>
- struct is_reference<_Tp&>
- : public true_type { };
-
- template<typename>
- struct is_member_object_pointer
- : public false_type { };
- _DEFINE_SPEC(2, is_member_object_pointer, _Tp _Cp::*,
- !is_function<_Tp>::value)
-
- template<typename>
- struct is_member_function_pointer
- : public false_type { };
- _DEFINE_SPEC(2, is_member_function_pointer, _Tp _Cp::*,
- is_function<_Tp>::value)
-
- template<typename _Tp>
- struct is_enum
- : public integral_constant<bool, __is_enum(_Tp)>
- { };
-
- template<typename _Tp>
- struct is_union
- : public integral_constant<bool, __is_union(_Tp)>
- { };
-
- template<typename _Tp>
- struct is_class
- : public integral_constant<bool, __is_class(_Tp)>
- { };
-
- template<typename>
- struct __is_function_helper
- : public false_type { };
-
- template<typename _Res, typename... _ArgTypes>
- struct __is_function_helper<_Res(_ArgTypes...)>
- : public true_type { };
-
- template<typename _Res, typename... _ArgTypes>
- struct __is_function_helper<_Res(_ArgTypes......)>
- : public true_type { };
-
- template<typename _Tp>
- struct is_function
- : public integral_constant<bool, (__is_function_helper<typename
- remove_cv<_Tp>::type>::value)>
- { };
-
- /// @brief composite type traits [4.5.2].
- template<typename _Tp>
- struct is_arithmetic
- : public integral_constant<bool, (is_integral<_Tp>::value
- || is_floating_point<_Tp>::value)>
- { };
-
- template<typename _Tp>
- struct is_fundamental
- : public integral_constant<bool, (is_arithmetic<_Tp>::value
- || is_void<_Tp>::value)>
- { };
-
- template<typename _Tp>
- struct is_object
- : public integral_constant<bool, !(is_function<_Tp>::value
- || is_reference<_Tp>::value
- || is_void<_Tp>::value)>
- { };
-
- template<typename _Tp>
- struct is_scalar
- : public integral_constant<bool, (is_arithmetic<_Tp>::value
- || is_enum<_Tp>::value
- || is_pointer<_Tp>::value
- || is_member_pointer<_Tp>::value)>
- { };
-
- template<typename _Tp>
- struct is_compound
- : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
-
- template<typename _Tp>
- struct is_member_pointer
- : public integral_constant<bool,
- (is_member_object_pointer<_Tp>::value
- || is_member_function_pointer<_Tp>::value)>
- { };
-
- /// @brief type properties [4.5.3].
- template<typename>
- struct is_const
+ struct is_signed
: public false_type { };
+ _DEFINE_SPEC(0, is_signed, signed char, true)
+ _DEFINE_SPEC(0, is_signed, short, true)
+ _DEFINE_SPEC(0, is_signed, int, true)
+ _DEFINE_SPEC(0, is_signed, long, true)
+ _DEFINE_SPEC(0, is_signed, long long, true)
- template<typename _Tp>
- struct is_const<_Tp const>
- : public true_type { };
-
template<typename>
- struct is_volatile
+ struct is_unsigned
: public false_type { };
-
- template<typename _Tp>
- struct is_volatile<_Tp volatile>
- : public true_type { };
+ _DEFINE_SPEC(0, is_unsigned, unsigned char, true)
+ _DEFINE_SPEC(0, is_unsigned, unsigned short, true)
+ _DEFINE_SPEC(0, is_unsigned, unsigned int, true)
+ _DEFINE_SPEC(0, is_unsigned, unsigned long, true)
+ _DEFINE_SPEC(0, is_unsigned, unsigned long long, true)
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp) || is_void<_Tp>::value>
{ };
- template<typename _Tp>
- struct is_empty
- : public integral_constant<bool, __is_empty(_Tp)>
- { };
-
- template<typename _Tp>
- struct is_polymorphic
- : public integral_constant<bool, __is_polymorphic(_Tp)>
- { };
-
- template<typename _Tp>
- struct is_abstract
- : public integral_constant<bool, __is_abstract(_Tp)>
- { };
-
template<typename _Tp>
struct has_trivial_constructor
- : public integral_constant<bool, is_pod<_Tp>::value> { };
+ : public integral_constant<bool, is_pod<_Tp>::value>
+ { };
template<typename _Tp>
struct has_trivial_copy
- : public integral_constant<bool, is_pod<_Tp>::value> { };
+ : public integral_constant<bool, is_pod<_Tp>::value>
+ { };
template<typename _Tp>
struct has_trivial_assign
- : public integral_constant<bool, is_pod<_Tp>::value> { };
+ : public integral_constant<bool, is_pod<_Tp>::value>
+ { };
template<typename _Tp>
struct has_trivial_destructor
- : public integral_constant<bool, is_pod<_Tp>::value> { };
+ : public integral_constant<bool, is_pod<_Tp>::value>
+ { };
template<typename _Tp>
struct has_nothrow_constructor
- : public integral_constant<bool, is_pod<_Tp>::value> { };
+ : public integral_constant<bool, is_pod<_Tp>::value>
+ { };
template<typename _Tp>
struct has_nothrow_copy
- : public integral_constant<bool, is_pod<_Tp>::value> { };
-
- template<typename _Tp>
- struct has_nothrow_assign
- : public integral_constant<bool, is_pod<_Tp>::value> { };
-
- template<typename _Tp>
- struct has_virtual_destructor
- : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+ : public integral_constant<bool, is_pod<_Tp>::value>
{ };
- template<typename>
- struct is_signed
- : public false_type { };
- _DEFINE_SPEC(0, is_signed, signed char, true)
- _DEFINE_SPEC(0, is_signed, short, true)
- _DEFINE_SPEC(0, is_signed, int, true)
- _DEFINE_SPEC(0, is_signed, long, true)
- _DEFINE_SPEC(0, is_signed, long long, true)
-
- template<typename>
- struct is_unsigned
- : public false_type { };
- _DEFINE_SPEC(0, is_unsigned, unsigned char, true)
- _DEFINE_SPEC(0, is_unsigned, unsigned short, true)
- _DEFINE_SPEC(0, is_unsigned, unsigned int, true)
- _DEFINE_SPEC(0, is_unsigned, unsigned long, true)
- _DEFINE_SPEC(0, is_unsigned, unsigned long long, true)
-
template<typename _Tp>
- struct alignment_of
- : public integral_constant<std::size_t, __alignof__(_Tp)> { };
-
- template<typename>
- struct rank
- : public integral_constant<std::size_t, 0> { };
-
- template<typename _Tp, std::size_t _Size>
- struct rank<_Tp[_Size]>
- : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
- template<typename _Tp>
- struct rank<_Tp[]>
- : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
- template<typename, unsigned>
- struct extent
- : public integral_constant<std::size_t, 0> { };
-
- template<typename _Tp, unsigned _Uint, std::size_t _Size>
- struct extent<_Tp[_Size], _Uint>
- : public integral_constant<std::size_t,
- _Uint == 0 ? _Size : extent<_Tp,
- _Uint - 1>::value>
- { };
-
- template<typename _Tp, unsigned _Uint>
- struct extent<_Tp[], _Uint>
- : public integral_constant<std::size_t,
- _Uint == 0 ? 0 : extent<_Tp,
- _Uint - 1>::value>
+ struct has_nothrow_assign
+ : public integral_constant<bool, is_pod<_Tp>::value>
{ };
-
- /// @brief relationships between types [4.6].
- template<typename, typename>
- struct is_same
- : public false_type { };
-
- template<typename _Tp>
- struct is_same<_Tp, _Tp>
- : public true_type { };
template<typename _Base, typename _Derived>
struct __is_base_of_helper
__is_convertible_helper<_From, _To>::__value>
{ };
- /// @brief const-volatile modifications [4.7.1].
- template<typename _Tp>
- struct remove_const
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_const<_Tp const>
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_volatile
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_volatile<_Tp volatile>
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_cv
- {
- typedef typename
- remove_const<typename remove_volatile<_Tp>::type>::type type;
- };
-
- template<typename _Tp>
- struct add_const
- { typedef _Tp const type; };
-
- template<typename _Tp>
- struct add_volatile
- { typedef _Tp volatile type; };
-
- template<typename _Tp>
- struct add_cv
- {
- typedef typename
- add_const<typename add_volatile<_Tp>::type>::type type;
- };
-
- /// @brief reference modifications [4.7.2].
- template<typename _Tp>
- struct remove_reference
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_reference<_Tp&>
- { typedef _Tp type; };
-
- // NB: Careful with reference to void.
- template<typename _Tp, bool = (is_void<_Tp>::value
- || is_reference<_Tp>::value)>
- struct __add_reference_helper
- { typedef _Tp& type; };
-
- template<typename _Tp>
- struct __add_reference_helper<_Tp, true>
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct add_reference
- : public __add_reference_helper<_Tp>
- { };
-
- /// @brief array modifications [4.7.3].
- template<typename _Tp>
- struct remove_extent
- { typedef _Tp type; };
-
- template<typename _Tp, std::size_t _Size>
- struct remove_extent<_Tp[_Size]>
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_extent<_Tp[]>
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_all_extents
- { typedef _Tp type; };
-
- template<typename _Tp, std::size_t _Size>
- struct remove_all_extents<_Tp[_Size]>
- { typedef typename remove_all_extents<_Tp>::type type; };
-
- template<typename _Tp>
- struct remove_all_extents<_Tp[]>
- { typedef typename remove_all_extents<_Tp>::type type; };
-
- /// @brief pointer modifications [4.7.4].
-#undef _DEFINE_SPEC_BODY
-#define _DEFINE_SPEC_BODY(_Value) \
- { typedef _Tp type; };
-
- template<typename _Tp>
- struct remove_pointer
- { typedef _Tp type; };
- _DEFINE_SPEC(1, remove_pointer, _Tp*, false)
-
- template<typename _Tp>
- struct add_pointer
- { typedef typename remove_reference<_Tp>::type* type; };
-
- /// @brief other transformations [4.8].
-
- // Due to c++/19163 and c++/17743, for the time being we cannot use
- // the correct, neat implementation :-(
- //
- // template<std::size_t _Len, std::size_t _Align>
- // struct aligned_storage
- // { typedef char type[_Len] __attribute__((__aligned__(_Align))); }
- //
- // Temporary workaround, useful for Align up to 32:
- template<std::size_t, std::size_t>
- struct aligned_storage { };
-
- template<std::size_t _Len>
- struct aligned_storage<_Len, 1>
- {
- union type
- {
- unsigned char __data[_Len];
- char __align __attribute__((__aligned__(1)));
- };
- };
-
- template<std::size_t _Len>
- struct aligned_storage<_Len, 2>
- {
- union type
- {
- unsigned char __data[_Len];
- char __align __attribute__((__aligned__(2)));
- };
- };
-
- template<std::size_t _Len>
- struct aligned_storage<_Len, 4>
- {
- union type
- {
- unsigned char __data[_Len];
- char __align __attribute__((__aligned__(4)));
- };
- };
-
- template<std::size_t _Len>
- struct aligned_storage<_Len, 8>
- {
- union type
- {
- unsigned char __data[_Len];
- char __align __attribute__((__aligned__(8)));
- };
- };
-
- template<std::size_t _Len>
- struct aligned_storage<_Len, 16>
- {
- union type
- {
- unsigned char __data[_Len];
- char __align __attribute__((__aligned__(16)));
- };
- };
-
- template<std::size_t _Len>
- struct aligned_storage<_Len, 32>
- {
- union type
- {
- unsigned char __data[_Len];
- char __align __attribute__((__aligned__(32)));
- };
- };
-
#undef _DEFINE_SPEC_0_HELPER
-#undef _DEFINE_SPEC_1_HELPER
-#undef _DEFINE_SPEC_2_HELPER
#undef _DEFINE_SPEC
#undef _DEFINE_SPEC_BODY
-
-_GLIBCXX_END_NAMESPACE
+}
}
-#endif
+#endif // _GLIBCXX_TR1_TYPE_TRAITS
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_UNORDERED_MAP
-#define _TR1_UNORDERED_MAP 1
-
-#include <tr1/hashtable>
+#ifndef _GLIBCXX_TR1_UNORDERED_MAP
+#define _GLIBCXX_TR1_UNORDERED_MAP 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <tr1/type_traits>
#include <tr1/functional_hash.h>
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // XXX When we get typedef templates these class definitions
- // will be unnecessary.
- template<class _Key, class _Tp,
- class _Hash = hash<_Key>,
- class _Pred = std::equal_to<_Key>,
- class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
- bool __cache_hash_code = false>
- class __unordered_map
- : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
- std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, false, true>
- {
- typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
- std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, false, true>
- _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- __unordered_map(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(),
- __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
- { }
-
- template<typename _InputIterator>
- __unordered_map(_InputIterator __f, _InputIterator __l,
- size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(),
- __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
- { }
- };
-
- template<class _Key, class _Tp,
- class _Hash = hash<_Key>,
- class _Pred = std::equal_to<_Key>,
- class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
- bool __cache_hash_code = false>
- class __unordered_multimap
- : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
- _Alloc,
- std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, false, false>
- {
- typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
- _Alloc,
- std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, false, false>
- _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- __unordered_multimap(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(),
- __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
- { }
-
-
- template<typename _InputIterator>
- __unordered_multimap(_InputIterator __f, _InputIterator __l,
- typename _Base::size_type __n = 0,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(),
- __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
- { }
- };
-
- template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
- bool __cache_hash_code>
- inline void
- swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __x,
- __unordered_map<_Key, _Tp, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __y)
- { __x.swap(__y); }
-
- template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
- bool __cache_hash_code>
- inline void
- swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __x,
- __unordered_multimap<_Key, _Tp, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __y)
- { __x.swap(__y); }
-
-
- template<class _Key, class _Tp,
- class _Hash = hash<_Key>,
- class _Pred = std::equal_to<_Key>,
- class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
- class unordered_map
- : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
- {
- typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- unordered_map(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __eql, __a)
- { }
-
- template<typename _InputIterator>
- unordered_map(_InputIterator __f, _InputIterator __l,
- size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __eql, __a)
- { }
- };
-
- template<class _Key, class _Tp,
- class _Hash = hash<_Key>,
- class _Pred = std::equal_to<_Key>,
- class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
- class unordered_multimap
- : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
- {
- typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- unordered_multimap(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __eql, __a)
- { }
-
-
- template<typename _InputIterator>
- unordered_multimap(_InputIterator __f, _InputIterator __l,
- typename _Base::size_type __n = 0,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __eql, __a)
- { }
- };
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#endif // _TR1_UNORDERED_MAP
+#include <tr1/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/unordered_map>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/unordered_map>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_UNORDERED_MAP
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_UNORDERED_SET
-#define _TR1_UNORDERED_SET 1
-
-#include <tr1/hashtable>
+#ifndef _GLIBCXX_TR1_UNORDERED_SET
+#define _GLIBCXX_TR1_UNORDERED_SET 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <algorithm> // lower_bound
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <tr1/type_traits>
#include <tr1/functional_hash.h>
-
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- // XXX When we get typedef templates these class definitions
- // will be unnecessary.
- template<class _Value,
- class _Hash = hash<_Value>,
- class _Pred = std::equal_to<_Value>,
- class _Alloc = std::allocator<_Value>,
- bool __cache_hash_code = false>
- class __unordered_set
- : public _Hashtable<_Value, _Value, _Alloc,
- std::_Identity<_Value>, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, true, true>
- {
- typedef _Hashtable<_Value, _Value, _Alloc,
- std::_Identity<_Value>, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, true, true>
- _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- __unordered_set(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(), __eql,
- std::_Identity<_Value>(), __a)
- { }
-
- template<typename _InputIterator>
- __unordered_set(_InputIterator __f, _InputIterator __l,
- size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(), __eql,
- std::_Identity<_Value>(), __a)
- { }
- };
-
- template<class _Value,
- class _Hash = hash<_Value>,
- class _Pred = std::equal_to<_Value>,
- class _Alloc = std::allocator<_Value>,
- bool __cache_hash_code = false>
- class __unordered_multiset
- : public _Hashtable<_Value, _Value, _Alloc,
- std::_Identity<_Value>, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, true, false>
- {
- typedef _Hashtable<_Value, _Value, _Alloc,
- std::_Identity<_Value>, _Pred,
- _Hash, __detail::_Mod_range_hashing,
- __detail::_Default_ranged_hash,
- __detail::_Prime_rehash_policy,
- __cache_hash_code, true, false>
- _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- __unordered_multiset(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(), __eql,
- std::_Identity<_Value>(), __a)
- { }
-
-
- template<typename _InputIterator>
- __unordered_multiset(_InputIterator __f, _InputIterator __l,
- typename _Base::size_type __n = 0,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
- __detail::_Default_ranged_hash(), __eql,
- std::_Identity<_Value>(), __a)
- { }
- };
-
- template<class _Value, class _Hash, class _Pred, class _Alloc,
- bool __cache_hash_code>
- inline void
- swap (__unordered_set<_Value, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __x,
- __unordered_set<_Value, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __y)
- { __x.swap(__y); }
-
- template<class _Value, class _Hash, class _Pred, class _Alloc,
- bool __cache_hash_code>
- inline void
- swap(__unordered_multiset<_Value, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __x,
- __unordered_multiset<_Value, _Hash, _Pred,
- _Alloc, __cache_hash_code>& __y)
- { __x.swap(__y); }
-
-
- template<class _Value,
- class _Hash = hash<_Value>,
- class _Pred = std::equal_to<_Value>,
- class _Alloc = std::allocator<_Value> >
- class unordered_set
- : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
- {
- typedef __unordered_set<_Value, _Hash, _Pred, _Alloc> _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- unordered_set(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __eql, __a)
- { }
-
- template<typename _InputIterator>
- unordered_set(_InputIterator __f, _InputIterator __l,
- size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __eql, __a)
- { }
- };
-
- template<class _Value,
- class _Hash = hash<_Value>,
- class _Pred = std::equal_to<_Value>,
- class _Alloc = std::allocator<_Value> >
- class unordered_multiset
- : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
- {
- typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc> _Base;
-
- public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
-
- explicit
- unordered_multiset(size_type __n = 10,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __eql, __a)
- { }
-
-
- template<typename _InputIterator>
- unordered_multiset(_InputIterator __f, _InputIterator __l,
- typename _Base::size_type __n = 0,
- const hasher& __hf = hasher(),
- const key_equal& __eql = key_equal(),
- const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __eql, __a)
- { }
- };
-
-_GLIBCXX_END_NAMESPACE
-}
-
-#endif // _TR1_UNORDERED_SET
+#include <tr1/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/unordered_set>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/unordered_set>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_UNORDERED_SET
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_UTILITY
-#define _TR1_UTILITY 1
+#ifndef _GLIBCXX_TR1_UTILITY
+#define _GLIBCXX_TR1_UTILITY 1
-#include <utility>
+#pragma GCC system_header
-namespace std
-{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
-
- template<class _Tp> class tuple_size;
- template<int _Int, class _Tp> class tuple_element;
-
- // Various functions which give std::pair a tuple-like interface.
- template<class _Tp1, class _Tp2>
- struct tuple_size<std::pair<_Tp1, _Tp2> >
- { static const int value = 2; };
-
- template<class _Tp1, class _Tp2>
- const int tuple_size<std::pair<_Tp1, _Tp2> >::value;
-
- template<class _Tp1, class _Tp2>
- struct tuple_element<0, std::pair<_Tp1, _Tp2> >
- { typedef _Tp1 type; };
-
- template<class _Tp1, class _Tp2>
- struct tuple_element<1, std::pair<_Tp1, _Tp2> >
- { typedef _Tp2 type; };
-
-
- template<int _Int> struct __pair_get;
-
- template<>
- struct __pair_get<0>
- {
- template<typename _Tp1, typename _Tp2>
- static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair)
- { return __pair.first; }
-
- template<typename _Tp1, typename _Tp2>
- static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
- { return __pair.first; }
- };
-
- template<>
- struct __pair_get<1>
- {
- template<typename _Tp1, typename _Tp2>
- static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair)
- { return __pair.second; }
-
- template<typename _Tp1, typename _Tp2>
- static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
- { return __pair.second; }
- };
-
- template<int _Int, class _Tp1, class _Tp2>
- inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
- get(std::pair<_Tp1, _Tp2>& __in)
- { return __pair_get<_Int>::__get(__in); }
-
- template<int _Int, class _Tp1, class _Tp2>
- inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
- get(const std::pair<_Tp1, _Tp2>& __in)
- { return __pair_get<_Int>::__const_get(__in); }
-
-_GLIBCXX_END_NAMESPACE
-}
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+# error TR1 header cannot be included from C++0x header
+#endif
+#include <bits/c++config.h>
+#include <bits/stl_relops.h>
+#include <bits/stl_pair.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+# include <tr1_impl/utility>
+#else
+# define _GLIBCXX_INCLUDE_AS_TR1
+# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+# define _GLIBCXX_END_NAMESPACE_TR1 }
+# define _GLIBCXX_TR1 tr1::
+# include <tr1_impl/utility>
+# undef _GLIBCXX_TR1
+# undef _GLIBCXX_END_NAMESPACE_TR1
+# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+# undef _GLIBCXX_INCLUDE_AS_TR1
#endif
+
+#endif // _GLIBCXX_TR1_UTILITY
// TR1 wchar.h -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_WCHAR_H
-#define _TR1_WCHAR_H 1
+#ifndef _GLIBCXX_TR1_WCHAR_H
+#define _GLIBCXX_TR1_WCHAR_H 1
#include <tr1/cwchar>
-#endif
+#endif // _GLIBCXX_TR1_WCHAR_H
// TR1 wctype.h -*- C++ -*-
-// Copyright (C) 2006 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* This is a TR1 C++ Library header.
*/
-#ifndef _TR1_WCTYPE_H
-#define _TR1_WCTYPE_H 1
+#ifndef _GLIBCXX_TR1_WCTYPE_H
+#define _GLIBCXX_TR1_WCTYPE_H 1
#include <tr1/cwctype>
-#endif
+#endif // _GLIBCXX_TR1_WCTYPE_H
--- /dev/null
+// class template array -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/array
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ /// @brief struct array [6.2.2].
+ /// NB: Requires complete type _Tp.
+ template<typename _Tp, std::size_t _Nm>
+ struct array
+ {
+ typedef _Tp value_type;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef value_type* iterator;
+ typedef const value_type* const_iterator;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ // Support for zero-sized arrays mandatory.
+ value_type _M_instance[_Nm ? _Nm : 1] __attribute__((__aligned__));
+
+ // No explicit construct/copy/destroy for aggregate type.
+
+ void
+ assign(const value_type& __u)
+ { std::fill_n(begin(), size(), __u); }
+
+ void
+ swap(array& __other)
+ { std::swap_ranges(begin(), end(), __other.begin()); }
+
+ // Iterators.
+ iterator
+ begin()
+ { return iterator(&_M_instance[0]); }
+
+ const_iterator
+ begin() const
+ { return const_iterator(&_M_instance[0]); }
+
+ iterator
+ end()
+ { return iterator(&_M_instance[_Nm]); }
+
+ const_iterator
+ end() const
+ { return const_iterator(&_M_instance[_Nm]); }
+
+ reverse_iterator
+ rbegin()
+ { return reverse_iterator(end()); }
+
+ const_reverse_iterator
+ rbegin() const
+ { return const_reverse_iterator(end()); }
+
+ reverse_iterator
+ rend()
+ { return reverse_iterator(begin()); }
+
+ const_reverse_iterator
+ rend() const
+ { return const_reverse_iterator(begin()); }
+
+ // Capacity.
+ size_type
+ size() const { return _Nm; }
+
+ size_type
+ max_size() const { return _Nm; }
+
+ bool
+ empty() const { return size() == 0; }
+
+ // Element access.
+ reference
+ operator[](size_type __n)
+ { return _M_instance[__n]; }
+
+ const_reference
+ operator[](size_type __n) const
+ { return _M_instance[__n]; }
+
+ reference
+ at(size_type __n)
+ {
+ _M_check<_Nm>(__n);
+ return _M_instance[__n];
+ }
+
+ const_reference
+ at(size_type __n) const
+ {
+ _M_check<_Nm>(__n);
+ return _M_instance[__n];
+ }
+
+ reference
+ front()
+ { return *begin(); }
+
+ const_reference
+ front() const
+ { return *begin(); }
+
+ reference
+ back()
+ { return _Nm ? *(end() - 1) : *end(); }
+
+ const_reference
+ back() const
+ { return _Nm ? *(end() - 1) : *end(); }
+
+ _Tp*
+ data()
+ { return &_M_instance[0]; }
+
+ const _Tp*
+ data() const
+ { return &_M_instance[0]; }
+
+ private:
+ template<std::size_t _Mm>
+ typename __gnu_cxx::__enable_if<_Mm, void>::__type
+ _M_check(size_type __n) const
+ {
+ if (__builtin_expect(__n >= _Mm, false))
+ std::__throw_out_of_range(__N("array::_M_check"));
+ }
+
+ // Avoid "unsigned comparison with zero" warnings.
+ template<std::size_t _Mm>
+ typename __gnu_cxx::__enable_if<!_Mm, void>::__type
+ _M_check(size_type) const
+ { std::__throw_out_of_range(__N("array::_M_check")); }
+ };
+
+ // Array comparisons.
+ template<typename _Tp, std::size_t _Nm>
+ inline bool
+ operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+ { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+ template<typename _Tp, std::size_t _Nm>
+ inline bool
+ operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+ { return !(__one == __two); }
+
+ template<typename _Tp, std::size_t _Nm>
+ inline bool
+ operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+ {
+ return std::lexicographical_compare(__a.begin(), __a.end(),
+ __b.begin(), __b.end());
+ }
+
+ template<typename _Tp, std::size_t _Nm>
+ inline bool
+ operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+ { return __two < __one; }
+
+ template<typename _Tp, std::size_t _Nm>
+ inline bool
+ operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+ { return !(__one > __two); }
+
+ template<typename _Tp, std::size_t _Nm>
+ inline bool
+ operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+ { return !(__one < __two); }
+
+ // Specialized algorithms [6.2.2.2].
+ template<typename _Tp, std::size_t _Nm>
+ inline void
+ swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+ { std::swap_ranges(__one.begin(), __one.end(), __two.begin()); }
+
+ // Tuple interface to class template array [6.2.2.5].
+ template<typename _Tp> class tuple_size;
+ template<int _Int, typename _Tp> class tuple_element;
+
+ template<typename _Tp, std::size_t _Nm>
+ struct tuple_size<array<_Tp, _Nm> >
+ { static const int value = _Nm; };
+
+ template<typename _Tp, std::size_t _Nm>
+ const int tuple_size<array<_Tp, _Nm> >::value;
+
+ template<int _Int, typename _Tp, std::size_t _Nm>
+ struct tuple_element<_Int, array<_Tp, _Nm> >
+ { typedef _Tp type; };
+
+ template<int _Int, typename _Tp, std::size_t _Nm>
+ inline _Tp&
+ get(array<_Tp, _Nm>& __arr)
+ { return __arr[_Int]; }
+
+ template<int _Int, typename _Tp, std::size_t _Nm>
+ inline const _Tp&
+ get(const array<_Tp, _Nm>& __arr)
+ { return __arr[_Int]; }
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
-// <tr1/boost_shared_ptr.h> -*- C++ -*-
+// <tr1_impl/boost_shared_ptr.h> -*- C++ -*-
-// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// GCC Note: based on version 1.32.0 of the Boost library.
-/** @file tr1/boost_shared_ptr.h
+/** @file tr1_impl/boost_shared_ptr.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
-#ifndef _BOOST_SHARED_PTR_H
-#define _BOOST_SHARED_PTR_H 1
-
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
class bad_weak_ptr : public std::exception
{
mutable weak_ptr<_Tp> _M_weak_this;
};
-_GLIBCXX_END_NAMESPACE
-} // namespace std
-
-#endif
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// TR1 cctype -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cctype
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_CTYPE_TR1
+
+#undef isblank
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ using ::isblank;
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
--- /dev/null
+// TR1 cfenv -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cfenv
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_FENV_TR1
+
+#include_next <fenv.h>
+
+#undef feclearexcept
+#undef fegetexceptflag
+#undef feraiseexcept
+#undef fesetexceptflag
+#undef fetestexcept
+#undef fegetround
+#undef fesetround
+#undef fegetenv
+#undef feholdexcept
+#undef fesetenv
+#undef feupdateenv
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // types
+ using ::fenv_t;
+ using ::fexcept_t;
+
+ // functions
+ using ::feclearexcept;
+ using ::fegetexceptflag;
+ using ::feraiseexcept;
+ using ::fesetexceptflag;
+ using ::fetestexcept;
+
+ using ::fegetround;
+ using ::fesetround;
+
+ using ::fegetenv;
+ using ::feholdexcept;
+ using ::fesetenv;
+ using ::feupdateenv;
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
--- /dev/null
+// TR1 cinttypes -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cinttypes
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_INTTYPES_TR1
+
+// For 8.11.1/1 (see C99, Note 184)
+#define __STDC_FORMAT_MACROS
+#include_next <inttypes.h>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // types
+ using ::imaxdiv_t;
+
+ // functions
+ using ::imaxabs;
+
+ // May collide with _Longlong abs(_Longlong), and is not described
+ // anywhere outside the synopsis. Likely, a defect.
+ //
+ // intmax_t abs(intmax_t)
+
+ using ::imaxdiv;
+
+ // Likewise, with lldiv_t div(_Longlong, _Longlong).
+ //
+ // imaxdiv_t div(intmax_t, intmax_t)
+
+ using ::strtoimax;
+ using ::strtoumax;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+ using ::wcstoimax;
+ using ::wcstoumax;
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
--- /dev/null
+// TR1 cmath -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cmath
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+#undef acosh
+#undef acoshf
+#undef acoshl
+#undef asinh
+#undef asinhf
+#undef asinhl
+#undef atanh
+#undef atanhf
+#undef atanhl
+#undef cbrt
+#undef cbrtf
+#undef cbrtl
+#undef copysign
+#undef copysignf
+#undef copysignl
+#undef erf
+#undef erff
+#undef erfl
+#undef erfc
+#undef erfcf
+#undef erfcl
+#undef exp2
+#undef exp2f
+#undef exp2l
+#undef expm1
+#undef expm1f
+#undef expm1l
+#undef fdim
+#undef fdimf
+#undef fdiml
+#undef fma
+#undef fmaf
+#undef fmal
+#undef fmax
+#undef fmaxf
+#undef fmaxl
+#undef fmin
+#undef fminf
+#undef fminl
+#undef hypot
+#undef hypotf
+#undef hypotl
+#undef ilogb
+#undef ilogbf
+#undef ilogbl
+#undef lgamma
+#undef lgammaf
+#undef lgammal
+#undef llrint
+#undef llrintf
+#undef llrintl
+#undef llround
+#undef llroundf
+#undef llroundl
+#undef log1p
+#undef log1pf
+#undef log1pl
+#undef log2
+#undef log2f
+#undef log2l
+#undef logb
+#undef logbf
+#undef logbl
+#undef lrint
+#undef lrintf
+#undef lrintl
+#undef lround
+#undef lroundf
+#undef lroundl
+#undef nan
+#undef nanf
+#undef nanl
+#undef nearbyint
+#undef nearbyintf
+#undef nearbyintl
+#undef nextafter
+#undef nextafterf
+#undef nextafterl
+#undef nexttoward
+#undef nexttowardf
+#undef nexttowardl
+#undef remainder
+#undef remainderf
+#undef remainderl
+#undef remquo
+#undef remquo
+#undef remquo
+#undef rint
+#undef rintf
+#undef rintl
+#undef round
+#undef roundf
+#undef roundl
+#undef scalbln
+#undef scalblnf
+#undef scalblnl
+#undef scalbn
+#undef scalbnf
+#undef scalbnl
+#undef tgamma
+#undef tgammaf
+#undef tgammal
+#undef trunc
+#undef truncf
+#undef truncl
+
+#endif
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+ // types
+ using ::double_t;
+ using ::float_t;
+
+ // functions
+ using ::acosh;
+ using ::acoshf;
+ using ::acoshl;
+
+ using ::asinh;
+ using ::asinhf;
+ using ::asinhl;
+
+ using ::atanh;
+ using ::atanhf;
+ using ::atanhl;
+
+ using ::cbrt;
+ using ::cbrtf;
+ using ::cbrtl;
+
+ using ::copysign;
+ using ::copysignf;
+ using ::copysignl;
+
+ using ::erf;
+ using ::erff;
+ using ::erfl;
+
+ using ::erfc;
+ using ::erfcf;
+ using ::erfcl;
+
+ using ::exp2;
+ using ::exp2f;
+ using ::exp2l;
+
+ using ::expm1;
+ using ::expm1f;
+ using ::expm1l;
+
+ using ::fdim;
+ using ::fdimf;
+ using ::fdiml;
+
+ using ::fma;
+ using ::fmaf;
+ using ::fmal;
+
+ using ::fmax;
+ using ::fmaxf;
+ using ::fmaxl;
+
+ using ::fmin;
+ using ::fminf;
+ using ::fminl;
+
+ using ::hypot;
+ using ::hypotf;
+ using ::hypotl;
+
+ using ::ilogb;
+ using ::ilogbf;
+ using ::ilogbl;
+
+ using ::lgamma;
+ using ::lgammaf;
+ using ::lgammal;
+
+ using ::llrint;
+ using ::llrintf;
+ using ::llrintl;
+
+ using ::llround;
+ using ::llroundf;
+ using ::llroundl;
+
+ using ::log1p;
+ using ::log1pf;
+ using ::log1pl;
+
+ using ::log2;
+ using ::log2f;
+ using ::log2l;
+
+ using ::logb;
+ using ::logbf;
+ using ::logbl;
+
+ using ::lrint;
+ using ::lrintf;
+ using ::lrintl;
+
+ using ::lround;
+ using ::lroundf;
+ using ::lroundl;
+
+ using ::nan;
+ using ::nanf;
+ using ::nanl;
+
+ using ::nearbyint;
+ using ::nearbyintf;
+ using ::nearbyintl;
+
+ using ::nextafter;
+ using ::nextafterf;
+ using ::nextafterl;
+
+ using ::nexttoward;
+ using ::nexttowardf;
+ using ::nexttowardl;
+
+ using ::remainder;
+ using ::remainderf;
+ using ::remainderl;
+
+ using ::remquo;
+ using ::remquo;
+ using ::remquo;
+
+ using ::rint;
+ using ::rintf;
+ using ::rintl;
+
+ using ::round;
+ using ::roundf;
+ using ::roundl;
+
+ using ::scalbln;
+ using ::scalblnf;
+ using ::scalblnl;
+
+ using ::scalbn;
+ using ::scalbnf;
+ using ::scalbnl;
+
+ using ::tgamma;
+ using ::tgammaf;
+ using ::tgammal;
+
+ using ::trunc;
+ using ::truncf;
+ using ::truncl;
+
+#endif
+
+#if _GLIBCXX_USE_C99_MATH
+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+
+ /// @brief Function template definitions [8.16.3].
+ //
+ using std::signbit;
+
+ using std::fpclassify;
+
+ using std::isfinite;
+ using std::isinf;
+ using std::isnan;
+ using std::isnormal;
+
+ using std::isgreater;
+ using std::isgreaterequal;
+ using std::isless;
+ using std::islessequal;
+ using std::islessgreater;
+ using std::isunordered;
+#endif
+#endif
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+ /// @brief Additional overloads [8.16.4].
+ //
+ using std::acos;
+
+ inline float
+ acosh(float __x)
+ { return __builtin_acoshf(__x); }
+
+ inline long double
+ acosh(long double __x)
+ { return __builtin_acoshl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ acosh(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return acosh(__type(__x));
+ }
+
+ using std::asin;
+
+ inline float
+ asinh(float __x)
+ { return __builtin_asinhf(__x); }
+
+ inline long double
+ asinh(long double __x)
+ { return __builtin_asinhl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ asinh(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return asinh(__type(__x));
+ }
+
+ using std::atan;
+ using std::atan2;
+
+ inline float
+ atanh(float __x)
+ { return __builtin_atanhf(__x); }
+
+ inline long double
+ atanh(long double __x)
+ { return __builtin_atanhl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ atanh(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return atanh(__type(__x));
+ }
+
+ inline float
+ cbrt(float __x)
+ { return __builtin_cbrtf(__x); }
+
+ inline long double
+ cbrt(long double __x)
+ { return __builtin_cbrtl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ cbrt(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return cbrt(__type(__x));
+ }
+
+ using std::ceil;
+
+ inline float
+ copysign(float __x, float __y)
+ { return __builtin_copysignf(__x, __y); }
+
+ inline long double
+ copysign(long double __x, long double __y)
+ { return __builtin_copysignl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ copysign(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return copysign(__type(__x), __type(__y));
+ }
+
+ using std::cos;
+ using std::cosh;
+
+ inline float
+ erf(float __x)
+ { return __builtin_erff(__x); }
+
+ inline long double
+ erf(long double __x)
+ { return __builtin_erfl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ erf(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return erf(__type(__x));
+ }
+
+ inline float
+ erfc(float __x)
+ { return __builtin_erfcf(__x); }
+
+ inline long double
+ erfc(long double __x)
+ { return __builtin_erfcl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ erfc(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return erfc(__type(__x));
+ }
+
+ using std::exp;
+
+ inline float
+ exp2(float __x)
+ { return __builtin_exp2f(__x); }
+
+ inline long double
+ exp2(long double __x)
+ { return __builtin_exp2l(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ exp2(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return exp2(__type(__x));
+ }
+
+ inline float
+ expm1(float __x)
+ { return __builtin_expm1f(__x); }
+
+ inline long double
+ expm1(long double __x)
+ { return __builtin_expm1l(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ expm1(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return expm1(__type(__x));
+ }
+
+ using std::fabs;
+
+ inline float
+ fdim(float __x, float __y)
+ { return __builtin_fdimf(__x, __y); }
+
+ inline long double
+ fdim(long double __x, long double __y)
+ { return __builtin_fdiml(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ fdim(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return fdim(__type(__x), __type(__y));
+ }
+
+ using std::floor;
+
+ inline float
+ fma(float __x, float __y, float __z)
+ { return __builtin_fmaf(__x, __y, __z); }
+
+ inline long double
+ fma(long double __x, long double __y, long double __z)
+ { return __builtin_fmal(__x, __y, __z); }
+
+ template<typename _Tp, typename _Up, typename _Vp>
+ inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+ fma(_Tp __x, _Up __y, _Vp __z)
+ {
+ typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+ return fma(__type(__x), __type(__y), __type(__z));
+ }
+
+ inline float
+ fmax(float __x, float __y)
+ { return __builtin_fmaxf(__x, __y); }
+
+ inline long double
+ fmax(long double __x, long double __y)
+ { return __builtin_fmaxl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ fmax(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return fmax(__type(__x), __type(__y));
+ }
+
+ inline float
+ fmin(float __x, float __y)
+ { return __builtin_fminf(__x, __y); }
+
+ inline long double
+ fmin(long double __x, long double __y)
+ { return __builtin_fminl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ fmin(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return fmin(__type(__x), __type(__y));
+ }
+
+ using std::fmod;
+ using std::frexp;
+
+ inline float
+ hypot(float __x, float __y)
+ { return __builtin_hypotf(__x, __y); }
+
+ inline long double
+ hypot(long double __x, long double __y)
+ { return __builtin_hypotl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ hypot(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return hypot(__type(__x), __type(__y));
+ }
+
+ inline int
+ ilogb(float __x)
+ { return __builtin_ilogbf(__x); }
+
+ inline int
+ ilogb(long double __x)
+ { return __builtin_ilogbl(__x); }
+
+ template<typename _Tp>
+ inline int
+ ilogb(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return ilogb(__type(__x));
+ }
+
+ using std::ldexp;
+
+ inline float
+ lgamma(float __x)
+ { return __builtin_lgammaf(__x); }
+
+ inline long double
+ lgamma(long double __x)
+ { return __builtin_lgammal(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ lgamma(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return lgamma(__type(__x));
+ }
+
+ inline long long
+ llrint(float __x)
+ { return __builtin_llrintf(__x); }
+
+ inline long long
+ llrint(long double __x)
+ { return __builtin_llrintl(__x); }
+
+ template<typename _Tp>
+ inline long long
+ llrint(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return llrint(__type(__x));
+ }
+
+ inline long long
+ llround(float __x)
+ { return __builtin_llroundf(__x); }
+
+ inline long long
+ llround(long double __x)
+ { return __builtin_llroundl(__x); }
+
+ template<typename _Tp>
+ inline long long
+ llround(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return llround(__type(__x));
+ }
+
+ using std::log;
+ using std::log10;
+
+ inline float
+ log1p(float __x)
+ { return __builtin_log1pf(__x); }
+
+ inline long double
+ log1p(long double __x)
+ { return __builtin_log1pl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ log1p(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return log1p(__type(__x));
+ }
+
+ // DR 568.
+ inline float
+ log2(float __x)
+ { return __builtin_log2f(__x); }
+
+ inline long double
+ log2(long double __x)
+ { return __builtin_log2l(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ log2(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return log2(__type(__x));
+ }
+
+ inline float
+ logb(float __x)
+ { return __builtin_logbf(__x); }
+
+ inline long double
+ logb(long double __x)
+ { return __builtin_logbl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ logb(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return logb(__type(__x));
+ }
+
+ inline long
+ lrint(float __x)
+ { return __builtin_lrintf(__x); }
+
+ inline long
+ lrint(long double __x)
+ { return __builtin_lrintl(__x); }
+
+ template<typename _Tp>
+ inline long
+ lrint(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return lrint(__type(__x));
+ }
+
+ inline long
+ lround(float __x)
+ { return __builtin_lroundf(__x); }
+
+ inline long
+ lround(long double __x)
+ { return __builtin_lroundl(__x); }
+
+ template<typename _Tp>
+ inline long
+ lround(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return lround(__type(__x));
+ }
+
+ inline float
+ nearbyint(float __x)
+ { return __builtin_nearbyintf(__x); }
+
+ inline long double
+ nearbyint(long double __x)
+ { return __builtin_nearbyintl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ nearbyint(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return nearbyint(__type(__x));
+ }
+
+ inline float
+ nextafter(float __x, float __y)
+ { return __builtin_nextafterf(__x, __y); }
+
+ inline long double
+ nextafter(long double __x, long double __y)
+ { return __builtin_nextafterl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ nextafter(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return nextafter(__type(__x), __type(__y));
+ }
+
+ inline float
+ nexttoward(float __x, long double __y)
+ { return __builtin_nexttowardf(__x, __y); }
+
+ inline long double
+ nexttoward(long double __x, long double __y)
+ { return __builtin_nexttowardl(__x, __y); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ nexttoward(_Tp __x, long double __y)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return nexttoward(__type(__x), __y);
+ }
+
+ using std::pow;
+
+ inline float
+ remainder(float __x, float __y)
+ { return __builtin_remainderf(__x, __y); }
+
+ inline long double
+ remainder(long double __x, long double __y)
+ { return __builtin_remainderl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ remainder(_Tp __x, _Up __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return remainder(__type(__x), __type(__y));
+ }
+
+ inline float
+ remquo(float __x, float __y, int* __pquo)
+ { return __builtin_remquof(__x, __y, __pquo); }
+
+ inline long double
+ remquo(long double __x, long double __y, int* __pquo)
+ { return __builtin_remquol(__x, __y, __pquo); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ remquo(_Tp __x, _Up __y, int* __pquo)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return remquo(__type(__x), __type(__y), __pquo);
+ }
+
+ inline float
+ rint(float __x)
+ { return __builtin_rintf(__x); }
+
+ inline long double
+ rint(long double __x)
+ { return __builtin_rintl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ rint(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return rint(__type(__x));
+ }
+
+ inline float
+ round(float __x)
+ { return __builtin_roundf(__x); }
+
+ inline long double
+ round(long double __x)
+ { return __builtin_roundl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ round(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return round(__type(__x));
+ }
+
+ inline float
+ scalbln(float __x, long __ex)
+ { return __builtin_scalblnf(__x, __ex); }
+
+ inline long double
+ scalbln(long double __x, long __ex)
+ { return __builtin_scalblnl(__x, __ex); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ scalbln(_Tp __x, long __ex)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return scalbln(__type(__x), __ex);
+ }
+
+ inline float
+ scalbn(float __x, int __ex)
+ { return __builtin_scalbnf(__x, __ex); }
+
+ inline long double
+ scalbn(long double __x, int __ex)
+ { return __builtin_scalbnl(__x, __ex); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ scalbn(_Tp __x, int __ex)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return scalbn(__type(__x), __ex);
+ }
+
+ using std::sin;
+ using std::sinh;
+ using std::sqrt;
+ using std::tan;
+ using std::tanh;
+
+ inline float
+ tgamma(float __x)
+ { return __builtin_tgammaf(__x); }
+
+ inline long double
+ tgamma(long double __x)
+ { return __builtin_tgammal(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ tgamma(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return tgamma(__type(__x));
+ }
+
+ inline float
+ trunc(float __x)
+ { return __builtin_truncf(__x); }
+
+ inline long double
+ trunc(long double __x)
+ { return __builtin_truncl(__x); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ trunc(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return trunc(__type(__x));
+ }
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// TR1 complex -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/complex
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // Forward declarations.
+ template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
+
+ template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
+
+ /// @brief acos(__z) [8.1.2].
+ // Effects: Behaves the same as C99 function cacos, defined
+ // in subclause 7.3.5.1.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ __complex_acos(const std::complex<_Tp>& __z)
+ {
+ const std::complex<_Tp> __t = std::_GLIBCXX_TR1 asin(__z);
+ const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
+ return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_acos(__complex__ float __z)
+ { return __builtin_cacosf(__z); }
+
+ inline __complex__ double
+ __complex_acos(__complex__ double __z)
+ { return __builtin_cacos(__z); }
+
+ inline __complex__ long double
+ __complex_acos(const __complex__ long double& __z)
+ { return __builtin_cacosl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acos(const std::complex<_Tp>& __z)
+ { return __complex_acos(__z.__rep()); }
+#else
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acos(const std::complex<_Tp>& __z)
+ { return __complex_acos(__z); }
+#endif
+
+ /// @brief asin(__z) [8.1.3].
+ // Effects: Behaves the same as C99 function casin, defined
+ // in subclause 7.3.5.2.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ __complex_asin(const std::complex<_Tp>& __z)
+ {
+ std::complex<_Tp> __t(-__z.imag(), __z.real());
+ __t = std::_GLIBCXX_TR1 asinh(__t);
+ return std::complex<_Tp>(__t.imag(), -__t.real());
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_asin(__complex__ float __z)
+ { return __builtin_casinf(__z); }
+
+ inline __complex__ double
+ __complex_asin(__complex__ double __z)
+ { return __builtin_casin(__z); }
+
+ inline __complex__ long double
+ __complex_asin(const __complex__ long double& __z)
+ { return __builtin_casinl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asin(const std::complex<_Tp>& __z)
+ { return __complex_asin(__z.__rep()); }
+#else
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asin(const std::complex<_Tp>& __z)
+ { return __complex_asin(__z); }
+#endif
+
+ /// @brief atan(__z) [8.1.4].
+ // Effects: Behaves the same as C99 function catan, defined
+ // in subclause 7.3.5.3.
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_atan(const std::complex<_Tp>& __z)
+ {
+ const _Tp __r2 = __z.real() * __z.real();
+ const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
+
+ _Tp __num = __z.imag() + _Tp(1.0);
+ _Tp __den = __z.imag() - _Tp(1.0);
+
+ __num = __r2 + __num * __num;
+ __den = __r2 + __den * __den;
+
+ return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
+ _Tp(0.25) * log(__num / __den));
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_atan(__complex__ float __z)
+ { return __builtin_catanf(__z); }
+
+ inline __complex__ double
+ __complex_atan(__complex__ double __z)
+ { return __builtin_catan(__z); }
+
+ inline __complex__ long double
+ __complex_atan(const __complex__ long double& __z)
+ { return __builtin_catanl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atan(const std::complex<_Tp>& __z)
+ { return __complex_atan(__z.__rep()); }
+#else
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atan(const std::complex<_Tp>& __z)
+ { return __complex_atan(__z); }
+#endif
+
+ /// @brief acosh(__z) [8.1.5].
+ // Effects: Behaves the same as C99 function cacosh, defined
+ // in subclause 7.3.6.1.
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_acosh(const std::complex<_Tp>& __z)
+ {
+ std::complex<_Tp> __t((__z.real() - __z.imag())
+ * (__z.real() + __z.imag()) - _Tp(1.0),
+ _Tp(2.0) * __z.real() * __z.imag());
+ __t = std::sqrt(__t);
+
+ return std::log(__t + __z);
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_acosh(__complex__ float __z)
+ { return __builtin_cacoshf(__z); }
+
+ inline __complex__ double
+ __complex_acosh(__complex__ double __z)
+ { return __builtin_cacosh(__z); }
+
+ inline __complex__ long double
+ __complex_acosh(const __complex__ long double& __z)
+ { return __builtin_cacoshl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acosh(const std::complex<_Tp>& __z)
+ { return __complex_acosh(__z.__rep()); }
+#else
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acosh(const std::complex<_Tp>& __z)
+ { return __complex_acosh(__z); }
+#endif
+
+ /// @brief asinh(__z) [8.1.6].
+ // Effects: Behaves the same as C99 function casin, defined
+ // in subclause 7.3.6.2.
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_asinh(const std::complex<_Tp>& __z)
+ {
+ std::complex<_Tp> __t((__z.real() - __z.imag())
+ * (__z.real() + __z.imag()) + _Tp(1.0),
+ _Tp(2.0) * __z.real() * __z.imag());
+ __t = std::sqrt(__t);
+
+ return std::log(__t + __z);
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_asinh(__complex__ float __z)
+ { return __builtin_casinhf(__z); }
+
+ inline __complex__ double
+ __complex_asinh(__complex__ double __z)
+ { return __builtin_casinh(__z); }
+
+ inline __complex__ long double
+ __complex_asinh(const __complex__ long double& __z)
+ { return __builtin_casinhl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asinh(const std::complex<_Tp>& __z)
+ { return __complex_asinh(__z.__rep()); }
+#else
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asinh(const std::complex<_Tp>& __z)
+ { return __complex_asinh(__z); }
+#endif
+
+ /// @brief atanh(__z) [8.1.7].
+ // Effects: Behaves the same as C99 function catanh, defined
+ // in subclause 7.3.6.3.
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_atanh(const std::complex<_Tp>& __z)
+ {
+ const _Tp __i2 = __z.imag() * __z.imag();
+ const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
+
+ _Tp __num = _Tp(1.0) + __z.real();
+ _Tp __den = _Tp(1.0) - __z.real();
+
+ __num = __i2 + __num * __num;
+ __den = __i2 + __den * __den;
+
+ return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
+ _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_atanh(__complex__ float __z)
+ { return __builtin_catanhf(__z); }
+
+ inline __complex__ double
+ __complex_atanh(__complex__ double __z)
+ { return __builtin_catanh(__z); }
+
+ inline __complex__ long double
+ __complex_atanh(const __complex__ long double& __z)
+ { return __builtin_catanhl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atanh(const std::complex<_Tp>& __z)
+ { return __complex_atanh(__z.__rep()); }
+#else
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atanh(const std::complex<_Tp>& __z)
+ { return __complex_atanh(__z); }
+#endif
+
+ /// @brief fabs(__z) [8.1.8].
+ // Effects: Behaves the same as C99 function cabs, defined
+ // in subclause 7.3.8.1.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ fabs(const std::complex<_Tp>& __z)
+ { return std::abs(__z); }
+
+
+#if (defined(_GLIBCXX_INCLUDE_AS_CXX0X) \
+ || (defined(_GLIBCXX_INCLUDE_AS_TR1) \
+ && !defined(__GXX_EXPERIMENTAL_CXX0X__)))
+
+ /// @brief Additional overloads [8.1.9].
+ //
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ arg(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return std::arg(std::complex<__type>(__x));
+ }
+
+ template<typename _Tp>
+ inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
+ conj(_Tp __x)
+ { return __x; }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ imag(_Tp)
+ { return _Tp(); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ norm(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return __type(__x) * __type(__x);
+ }
+
+ template<typename _Tp, typename _Up>
+ inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+ polar(const _Tp& __rho, const _Up& __theta)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return std::polar(__type(__rho), __type(__theta));
+ }
+
+ template<typename _Tp, typename _Up>
+ inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+ pow(const std::complex<_Tp>& __x, const _Up& __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return std::pow(std::complex<__type>(__x), __type(__y));
+ }
+
+ template<typename _Tp, typename _Up>
+ inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+ pow(const _Tp& __x, const std::complex<_Up>& __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return std::pow(__type(__x), std::complex<__type>(__y));
+ }
+
+ template<typename _Tp, typename _Up>
+ inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+ pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return std::pow(std::complex<__type>(__x),
+ std::complex<__type>(__y));
+ }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ real(_Tp __x)
+ { return __x; }
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// TR1 cstdint -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cstdint
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_C99_STDINT_TR1
+
+// For 8.22.1/1 (see C99, Notes 219, 220, 222)
+#define __STDC_LIMIT_MACROS
+#define __STDC_CONSTANT_MACROS
+#include_next <stdint.h>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ using ::int8_t;
+ using ::int16_t;
+ using ::int32_t;
+ using ::int64_t;
+
+ using ::int_fast8_t;
+ using ::int_fast16_t;
+ using ::int_fast32_t;
+ using ::int_fast64_t;
+
+ using ::int_least8_t;
+ using ::int_least16_t;
+ using ::int_least32_t;
+ using ::int_least64_t;
+
+ using ::intmax_t;
+ using ::intptr_t;
+
+ using ::uint8_t;
+ using ::uint16_t;
+ using ::uint32_t;
+ using ::uint64_t;
+
+ using ::uint_fast8_t;
+ using ::uint_fast16_t;
+ using ::uint_fast32_t;
+ using ::uint_fast64_t;
+
+ using ::uint_least8_t;
+ using ::uint_least16_t;
+ using ::uint_least32_t;
+ using ::uint_least64_t;
+
+ using ::uintmax_t;
+ using ::uintptr_t;
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
--- /dev/null
+// TR1 cstdio -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cstdio
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_USE_C99
+ using std::snprintf;
+ using std::vsnprintf;
+
+ using std::vfscanf;
+ using std::vscanf;
+ using std::vsscanf;
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// TR1 cstdlib -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cstdlib
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_HOSTED
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_USE_C99
+
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+ // types
+ using std::lldiv_t;
+
+ // functions
+ using std::llabs;
+ using std::lldiv;
+#endif
+
+ using std::atoll;
+ using std::strtoll;
+ using std::strtoull;
+
+ using std::strtof;
+ using std::strtold;
+
+ // overloads
+ using std::abs;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+ using std::div;
+#endif
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
--- /dev/null
+// TR1 cwchar -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cwchar
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_HAVE_WCSTOF
+ using std::wcstof;
+#endif
+#if _GLIBCXX_HAVE_VFWSCANF
+ using std::vfwscanf;
+#endif
+#if _GLIBCXX_HAVE_VSWSCANF
+ using std::vswscanf;
+#endif
+#if _GLIBCXX_HAVE_VWSCANF
+ using std::vwscanf;
+#endif
+
+#if _GLIBCXX_USE_C99
+ using std::wcstold;
+ using std::wcstoll;
+ using std::wcstoull;
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
--- /dev/null
+// TR1 cwctype -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/cwctype
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+#if _GLIBCXX_HAVE_ISWBLANK
+ using std::iswblank;
+#endif
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#endif
--- /dev/null
+// TR1 functional header -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/functional
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ template<typename _MemberPointer>
+ class _Mem_fn;
+
+ /**
+ * @if maint
+ * Actual implementation of _Has_result_type, which uses SFINAE to
+ * determine if the type _Tp has a publicly-accessible member type
+ * result_type.
+ * @endif
+ */
+ template<typename _Tp>
+ class _Has_result_type_helper : __sfinae_types
+ {
+ template<typename _Up>
+ struct _Wrap_type
+ { };
+
+ template<typename _Up>
+ static __one __test(_Wrap_type<typename _Up::result_type>*);
+
+ template<typename _Up>
+ static __two __test(...);
+
+ public:
+ static const bool value = sizeof(__test<_Tp>(0)) == 1;
+ };
+
+ template<typename _Tp>
+ struct _Has_result_type
+ : integral_constant<bool,
+ _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
+ { };
+
+ /**
+ * @if maint
+ * If we have found a result_type, extract it.
+ * @endif
+ */
+ template<bool _Has_result_type, typename _Functor>
+ struct _Maybe_get_result_type
+ { };
+
+ template<typename _Functor>
+ struct _Maybe_get_result_type<true, _Functor>
+ {
+ typedef typename _Functor::result_type result_type;
+ };
+
+ /**
+ * @if maint
+ * Base class for any function object that has a weak result type, as
+ * defined in 3.3/3 of TR1.
+ * @endif
+ */
+ template<typename _Functor>
+ struct _Weak_result_type_impl
+ : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
+ {
+ };
+
+ /**
+ * @if maint
+ * Retrieve the result type for a function type.
+ * @endif
+ */
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes...)>
+ {
+ typedef _Res result_type;
+ };
+
+ /**
+ * @if maint
+ * Retrieve the result type for a function reference.
+ * @endif
+ */
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
+ {
+ typedef _Res result_type;
+ };
+
+ /**
+ * @if maint
+ * Retrieve the result type for a function pointer.
+ * @endif
+ */
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
+ {
+ typedef _Res result_type;
+ };
+
+ /**
+ * @if maint
+ * Retrieve result type for a member function pointer.
+ * @endif maint
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
+ {
+ typedef _Res result_type;
+ };
+
+ /**
+ * @if maint
+ * Retrieve result type for a const member function pointer.
+ * @endif maint
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
+ {
+ typedef _Res result_type;
+ };
+
+ /**
+ * @if maint
+ * Retrieve result type for a volatile member function pointer.
+ * @endif maint
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
+ {
+ typedef _Res result_type;
+ };
+
+ /**
+ * @if maint
+ * Retrieve result type for a const volatile member function pointer.
+ * @endif maint
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile>
+ {
+ typedef _Res result_type;
+ };
+
+ /**
+ * @if maint
+ * Strip top-level cv-qualifiers from the function object and let
+ * _Weak_result_type_impl perform the real work.
+ * @endif
+ */
+ template<typename _Functor>
+ struct _Weak_result_type
+ : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
+ {
+ };
+
+ template<typename _Signature>
+ class result_of;
+
+ /**
+ * @if maint
+ * Actual implementation of result_of. When _Has_result_type is
+ * true, gets its result from _Weak_result_type. Otherwise, uses
+ * the function object's member template result to extract the
+ * result type.
+ * @endif
+ */
+ template<bool _Has_result_type, typename _Signature>
+ struct _Result_of_impl;
+
+ // Handle member data pointers using _Mem_fn's logic
+ template<typename _Res, typename _Class, typename _T1>
+ struct _Result_of_impl<false, _Res _Class::*(_T1)>
+ {
+ typedef typename _Mem_fn<_Res _Class::*>
+ ::template _Result_type<_T1>::type type;
+ };
+
+ /**
+ * @if maint
+ * Determine whether we can determine a result type from @c Functor
+ * alone.
+ * @endif
+ */
+ template<typename _Functor, typename... _ArgTypes>
+ class result_of<_Functor(_ArgTypes...)>
+ : public _Result_of_impl<
+ _Has_result_type<_Weak_result_type<_Functor> >::value,
+ _Functor(_ArgTypes...)>
+ {
+ };
+
+ /**
+ * @if maint
+ * We already know the result type for @c Functor; use it.
+ * @endif
+ */
+ template<typename _Functor, typename... _ArgTypes>
+ struct _Result_of_impl<true, _Functor(_ArgTypes...)>
+ {
+ typedef typename _Weak_result_type<_Functor>::result_type type;
+ };
+
+ /**
+ * @if maint
+ * We need to compute the result type for this invocation the hard
+ * way.
+ * @endif
+ */
+ template<typename _Functor, typename... _ArgTypes>
+ struct _Result_of_impl<false, _Functor(_ArgTypes...)>
+ {
+ typedef typename _Functor
+ ::template result<_Functor(_ArgTypes...)>::type type;
+ };
+
+ /**
+ * @if maint
+ * It is unsafe to access ::result when there are zero arguments, so we
+ * return @c void instead.
+ * @endif
+ */
+ template<typename _Functor>
+ struct _Result_of_impl<false, _Functor()>
+ {
+ typedef void type;
+ };
+
+ /**
+ * @if maint
+ * Determines if the type _Tp derives from unary_function.
+ * @endif
+ */
+ template<typename _Tp>
+ struct _Derives_from_unary_function : __sfinae_types
+ {
+ private:
+ template<typename _T1, typename _Res>
+ static __one __test(const volatile unary_function<_T1, _Res>*);
+
+ // It's tempting to change "..." to const volatile void*, but
+ // that fails when _Tp is a function type.
+ static __two __test(...);
+
+ public:
+ static const bool value = sizeof(__test((_Tp*)0)) == 1;
+ };
+
+ /**
+ * @if maint
+ * Determines if the type _Tp derives from binary_function.
+ * @endif
+ */
+ template<typename _Tp>
+ struct _Derives_from_binary_function : __sfinae_types
+ {
+ private:
+ template<typename _T1, typename _T2, typename _Res>
+ static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
+
+ // It's tempting to change "..." to const volatile void*, but
+ // that fails when _Tp is a function type.
+ static __two __test(...);
+
+ public:
+ static const bool value = sizeof(__test((_Tp*)0)) == 1;
+ };
+
+ /**
+ * @if maint
+ * Turns a function type into a function pointer type
+ * @endif
+ */
+ template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
+ struct _Function_to_function_pointer
+ {
+ typedef _Tp type;
+ };
+
+ template<typename _Tp>
+ struct _Function_to_function_pointer<_Tp, true>
+ {
+ typedef _Tp* type;
+ };
+
+ /**
+ * @if maint
+ * Invoke a function object, which may be either a member pointer or a
+ * function object. The first parameter will tell which.
+ * @endif
+ */
+ template<typename _Functor, typename... _Args>
+ inline
+ typename __gnu_cxx::__enable_if<
+ (!is_member_pointer<_Functor>::value
+ && !is_function<_Functor>::value
+ && !is_function<typename remove_pointer<_Functor>::type>::value),
+ typename result_of<_Functor(_Args...)>::type
+ >::__type
+ __invoke(_Functor& __f, _Args&... __args)
+ {
+ return __f(__args...);
+ }
+
+ template<typename _Functor, typename... _Args>
+ inline
+ typename __gnu_cxx::__enable_if<
+ (is_member_pointer<_Functor>::value
+ && !is_function<_Functor>::value
+ && !is_function<typename remove_pointer<_Functor>::type>::value),
+ typename result_of<_Functor(_Args...)>::type
+ >::__type
+ __invoke(_Functor& __f, _Args&... __args)
+ {
+ return mem_fn(__f)(__args...);
+ }
+
+ // To pick up function references (that will become function pointers)
+ template<typename _Functor, typename... _Args>
+ inline
+ typename __gnu_cxx::__enable_if<
+ (is_pointer<_Functor>::value
+ && is_function<typename remove_pointer<_Functor>::type>::value),
+ typename result_of<_Functor(_Args...)>::type
+ >::__type
+ __invoke(_Functor __f, _Args&... __args)
+ {
+ return __f(__args...);
+ }
+
+ /**
+ * @if maint
+ * Knowing which of unary_function and binary_function _Tp derives
+ * from, derives from the same and ensures that reference_wrapper
+ * will have a weak result type. See cases below.
+ * @endif
+ */
+ template<bool _Unary, bool _Binary, typename _Tp>
+ struct _Reference_wrapper_base_impl;
+
+ // Not a unary_function or binary_function, so try a weak result type
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<false, false, _Tp>
+ : _Weak_result_type<_Tp>
+ { };
+
+ // unary_function but not binary_function
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<true, false, _Tp>
+ : unary_function<typename _Tp::argument_type,
+ typename _Tp::result_type>
+ { };
+
+ // binary_function but not unary_function
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<false, true, _Tp>
+ : binary_function<typename _Tp::first_argument_type,
+ typename _Tp::second_argument_type,
+ typename _Tp::result_type>
+ { };
+
+ // both unary_function and binary_function. import result_type to
+ // avoid conflicts.
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<true, true, _Tp>
+ : unary_function<typename _Tp::argument_type,
+ typename _Tp::result_type>,
+ binary_function<typename _Tp::first_argument_type,
+ typename _Tp::second_argument_type,
+ typename _Tp::result_type>
+ {
+ typedef typename _Tp::result_type result_type;
+ };
+
+ /**
+ * @if maint
+ * Derives from unary_function or binary_function when it
+ * can. Specializations handle all of the easy cases. The primary
+ * template determines what to do with a class type, which may
+ * derive from both unary_function and binary_function.
+ * @endif
+ */
+ template<typename _Tp>
+ struct _Reference_wrapper_base
+ : _Reference_wrapper_base_impl<
+ _Derives_from_unary_function<_Tp>::value,
+ _Derives_from_binary_function<_Tp>::value,
+ _Tp>
+ { };
+
+ // - a function type (unary)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res(_T1)>
+ : unary_function<_T1, _Res>
+ { };
+
+ // - a function type (binary)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res(_T1, _T2)>
+ : binary_function<_T1, _T2, _Res>
+ { };
+
+ // - a function pointer type (unary)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res(*)(_T1)>
+ : unary_function<_T1, _Res>
+ { };
+
+ // - a function pointer type (binary)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
+ : binary_function<_T1, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, no qualifiers)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)()>
+ : unary_function<_T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, no qualifiers)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
+ : binary_function<_T1*, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, const)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)() const>
+ : unary_function<const _T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, const)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
+ : binary_function<const _T1*, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, volatile)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
+ : unary_function<volatile _T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, volatile)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
+ : binary_function<volatile _T1*, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, const volatile)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
+ : unary_function<const volatile _T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, const volatile)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
+ : binary_function<const volatile _T1*, _T2, _Res>
+ { };
+
+ template<typename _Tp>
+ class reference_wrapper
+ : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
+ {
+ // If _Tp is a function type, we can't form result_of<_Tp(...)>,
+ // so turn it into a function pointer type.
+ typedef typename _Function_to_function_pointer<_Tp>::type
+ _M_func_type;
+
+ _Tp* _M_data;
+ public:
+ typedef _Tp type;
+
+ explicit
+ reference_wrapper(_Tp& __indata): _M_data(&__indata)
+ { }
+
+ reference_wrapper(const reference_wrapper<_Tp>& __inref):
+ _M_data(__inref._M_data)
+ { }
+
+ reference_wrapper&
+ operator=(const reference_wrapper<_Tp>& __inref)
+ {
+ _M_data = __inref._M_data;
+ return *this;
+ }
+
+ operator _Tp&() const
+ { return this->get(); }
+
+ _Tp&
+ get() const
+ { return *_M_data; }
+
+ template<typename... _Args>
+ typename result_of<_M_func_type(_Args...)>::type
+ operator()(_Args&... __args) const
+ {
+ return __invoke(get(), __args...);
+ }
+ };
+
+
+ // Denotes a reference should be taken to a variable.
+ template<typename _Tp>
+ inline reference_wrapper<_Tp>
+ ref(_Tp& __t)
+ { return reference_wrapper<_Tp>(__t); }
+
+ // Denotes a const reference should be taken to a variable.
+ template<typename _Tp>
+ inline reference_wrapper<const _Tp>
+ cref(const _Tp& __t)
+ { return reference_wrapper<const _Tp>(__t); }
+
+ template<typename _Tp>
+ inline reference_wrapper<_Tp>
+ ref(reference_wrapper<_Tp> __t)
+ { return ref(__t.get()); }
+
+ template<typename _Tp>
+ inline reference_wrapper<const _Tp>
+ cref(reference_wrapper<_Tp> __t)
+ { return cref(__t.get()); }
+
+ template<typename _Tp, bool>
+ struct _Mem_fn_const_or_non
+ {
+ typedef const _Tp& type;
+ };
+
+ template<typename _Tp>
+ struct _Mem_fn_const_or_non<_Tp, false>
+ {
+ typedef _Tp& type;
+ };
+
+ /**
+ * @if maint
+ * Derives from @c unary_function or @c binary_function, or perhaps
+ * nothing, depending on the number of arguments provided. The
+ * primary template is the basis case, which derives nothing.
+ * @endif maint
+ */
+ template<typename _Res, typename... _ArgTypes>
+ struct _Maybe_unary_or_binary_function { };
+
+ /**
+ * @if maint
+ * Derives from @c unary_function, as appropriate.
+ * @endif
+ */
+ template<typename _Res, typename _T1>
+ struct _Maybe_unary_or_binary_function<_Res, _T1>
+ : std::unary_function<_T1, _Res> { };
+
+ /**
+ * @if maint
+ * Derives from @c binary_function, as appropriate.
+ * @endif
+ */
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+ : std::binary_function<_T1, _T2, _Res> { };
+
+ /**
+ * @if maint
+ * Implementation of @c mem_fn for member function pointers.
+ * @endif
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
+ : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
+ {
+ typedef _Res (_Class::*_Functor)(_ArgTypes...);
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(__args...); }
+
+ public:
+ typedef _Res result_type;
+
+ explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+ // Handle objects
+ _Res
+ operator()(_Class& __object, _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ // Handle pointers
+ _Res
+ operator()(_Class* __object, _ArgTypes... __args) const
+ { return (__object->*__pmf)(__args...); }
+
+ // Handle smart pointers, references and pointers to derived
+ template<typename _Tp>
+ _Res
+ operator()(_Tp& __object, _ArgTypes... __args) const
+ { return _M_call(__object, &__object, __args...); }
+
+ private:
+ _Functor __pmf;
+ };
+
+ /**
+ * @if maint
+ * Implementation of @c mem_fn for const member function pointers.
+ * @endif
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
+ : public _Maybe_unary_or_binary_function<_Res, const _Class*,
+ _ArgTypes...>
+ {
+ typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(__args...); }
+
+ public:
+ typedef _Res result_type;
+
+ explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+ // Handle objects
+ _Res
+ operator()(const _Class& __object, _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ // Handle pointers
+ _Res
+ operator()(const _Class* __object, _ArgTypes... __args) const
+ { return (__object->*__pmf)(__args...); }
+
+ // Handle smart pointers, references and pointers to derived
+ template<typename _Tp>
+ _Res operator()(_Tp& __object, _ArgTypes... __args) const
+ { return _M_call(__object, &__object, __args...); }
+
+ private:
+ _Functor __pmf;
+ };
+
+ /**
+ * @if maint
+ * Implementation of @c mem_fn for volatile member function pointers.
+ * @endif
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
+ : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
+ _ArgTypes...>
+ {
+ typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(__args...); }
+
+ public:
+ typedef _Res result_type;
+
+ explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+ // Handle objects
+ _Res
+ operator()(volatile _Class& __object, _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ // Handle pointers
+ _Res
+ operator()(volatile _Class* __object, _ArgTypes... __args) const
+ { return (__object->*__pmf)(__args...); }
+
+ // Handle smart pointers, references and pointers to derived
+ template<typename _Tp>
+ _Res
+ operator()(_Tp& __object, _ArgTypes... __args) const
+ { return _M_call(__object, &__object, __args...); }
+
+ private:
+ _Functor __pmf;
+ };
+
+ /**
+ * @if maint
+ * Implementation of @c mem_fn for const volatile member function pointers.
+ * @endif
+ */
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
+ : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
+ _ArgTypes...>
+ {
+ typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ template<typename _Tp>
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(__args...); }
+
+ public:
+ typedef _Res result_type;
+
+ explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+ // Handle objects
+ _Res
+ operator()(const volatile _Class& __object, _ArgTypes... __args) const
+ { return (__object.*__pmf)(__args...); }
+
+ // Handle pointers
+ _Res
+ operator()(const volatile _Class* __object, _ArgTypes... __args) const
+ { return (__object->*__pmf)(__args...); }
+
+ // Handle smart pointers, references and pointers to derived
+ template<typename _Tp>
+ _Res operator()(_Tp& __object, _ArgTypes... __args) const
+ { return _M_call(__object, &__object, __args...); }
+
+ private:
+ _Functor __pmf;
+ };
+
+
+ template<typename _Res, typename _Class>
+ class _Mem_fn<_Res _Class::*>
+ {
+ // This bit of genius is due to Peter Dimov, improved slightly by
+ // Douglas Gregor.
+ template<typename _Tp>
+ _Res&
+ _M_call(_Tp& __object, _Class *) const
+ { return __object.*__pm; }
+
+ template<typename _Tp, typename _Up>
+ _Res&
+ _M_call(_Tp& __object, _Up * const *) const
+ { return (*__object).*__pm; }
+
+ template<typename _Tp, typename _Up>
+ const _Res&
+ _M_call(_Tp& __object, const _Up * const *) const
+ { return (*__object).*__pm; }
+
+ template<typename _Tp>
+ const _Res&
+ _M_call(_Tp& __object, const _Class *) const
+ { return __object.*__pm; }
+
+ template<typename _Tp>
+ const _Res&
+ _M_call(_Tp& __ptr, const volatile void*) const
+ { return (*__ptr).*__pm; }
+
+ template<typename _Tp> static _Tp& __get_ref();
+
+ template<typename _Tp>
+ static __sfinae_types::__one __check_const(_Tp&, _Class*);
+ template<typename _Tp, typename _Up>
+ static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
+ template<typename _Tp, typename _Up>
+ static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
+ template<typename _Tp>
+ static __sfinae_types::__two __check_const(_Tp&, const _Class*);
+ template<typename _Tp>
+ static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
+
+ public:
+ template<typename _Tp>
+ struct _Result_type
+ : _Mem_fn_const_or_non<_Res,
+ (sizeof(__sfinae_types::__two)
+ == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
+ { };
+
+ template<typename _Signature>
+ struct result;
+
+ template<typename _CVMem, typename _Tp>
+ struct result<_CVMem(_Tp)>
+ : public _Result_type<_Tp> { };
+
+ template<typename _CVMem, typename _Tp>
+ struct result<_CVMem(_Tp&)>
+ : public _Result_type<_Tp> { };
+
+ explicit
+ _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
+
+ // Handle objects
+ _Res&
+ operator()(_Class& __object) const
+ { return __object.*__pm; }
+
+ const _Res&
+ operator()(const _Class& __object) const
+ { return __object.*__pm; }
+
+ // Handle pointers
+ _Res&
+ operator()(_Class* __object) const
+ { return __object->*__pm; }
+
+ const _Res&
+ operator()(const _Class* __object) const
+ { return __object->*__pm; }
+
+ // Handle smart pointers and derived
+ template<typename _Tp>
+ typename _Result_type<_Tp>::type
+ operator()(_Tp& __unknown) const
+ { return _M_call(__unknown, &__unknown); }
+
+ private:
+ _Res _Class::*__pm;
+ };
+
+ /**
+ * @brief Returns a function object that forwards to the member
+ * pointer @a pm.
+ */
+ template<typename _Tp, typename _Class>
+ inline _Mem_fn<_Tp _Class::*>
+ mem_fn(_Tp _Class::* __pm)
+ {
+ return _Mem_fn<_Tp _Class::*>(__pm);
+ }
+
+ /**
+ * @brief Determines if the given type _Tp is a function object
+ * should be treated as a subexpression when evaluating calls to
+ * function objects returned by bind(). [TR1 3.6.1]
+ */
+ template<typename _Tp>
+ struct is_bind_expression
+ { static const bool value = false; };
+
+ template<typename _Tp>
+ const bool is_bind_expression<_Tp>::value;
+
+ /**
+ * @brief Determines if the given type _Tp is a placeholder in a
+ * bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
+ */
+ template<typename _Tp>
+ struct is_placeholder
+ { static const int value = 0; };
+
+ template<typename _Tp>
+ const int is_placeholder<_Tp>::value;
+
+ /**
+ * @if maint
+ * The type of placeholder objects defined by libstdc++.
+ * @endif
+ */
+ template<int _Num> struct _Placeholder { };
+
+ // Define a large number of placeholders. There is no way to
+ // simplify this with variadic templates, because we're introducing
+ // unique names for each.
+ namespace placeholders { namespace {
+ _Placeholder<1> _1;
+ _Placeholder<2> _2;
+ _Placeholder<3> _3;
+ _Placeholder<4> _4;
+ _Placeholder<5> _5;
+ _Placeholder<6> _6;
+ _Placeholder<7> _7;
+ _Placeholder<8> _8;
+ _Placeholder<9> _9;
+ _Placeholder<10> _10;
+ _Placeholder<11> _11;
+ _Placeholder<12> _12;
+ _Placeholder<13> _13;
+ _Placeholder<14> _14;
+ _Placeholder<15> _15;
+ _Placeholder<16> _16;
+ _Placeholder<17> _17;
+ _Placeholder<18> _18;
+ _Placeholder<19> _19;
+ _Placeholder<20> _20;
+ _Placeholder<21> _21;
+ _Placeholder<22> _22;
+ _Placeholder<23> _23;
+ _Placeholder<24> _24;
+ _Placeholder<25> _25;
+ _Placeholder<26> _26;
+ _Placeholder<27> _27;
+ _Placeholder<28> _28;
+ _Placeholder<29> _29;
+ } }
+
+ /**
+ * @if maint
+ * Partial specialization of is_placeholder that provides the placeholder
+ * number for the placeholder objects defined by libstdc++.
+ * @endif
+ */
+ template<int _Num>
+ struct is_placeholder<_Placeholder<_Num> >
+ { static const int value = _Num; };
+
+ template<int _Num>
+ const int is_placeholder<_Placeholder<_Num> >::value;
+
+ /**
+ * @if maint
+ * Stores a tuple of indices. Used by bind() to extract the elements
+ * in a tuple.
+ * @endif
+ */
+ template<int... _Indexes>
+ struct _Index_tuple { };
+
+ /**
+ * @if maint
+ * Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
+ * @endif
+ */
+ template<std::size_t _Num, typename _Tuple = _Index_tuple<> >
+ struct _Build_index_tuple;
+
+ template<std::size_t _Num, int... _Indexes>
+ struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
+ : _Build_index_tuple<_Num - 1,
+ _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
+ {
+ };
+
+ template<int... _Indexes>
+ struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
+ {
+ typedef _Index_tuple<_Indexes...> __type;
+ };
+
+ /**
+ * @if maint
+ * Used by _Safe_tuple_element to indicate that there is no tuple
+ * element at this position.
+ * @endif
+ */
+ struct _No_tuple_element;
+
+ /**
+ * @if maint
+ * Implementation helper for _Safe_tuple_element. This primary
+ * template handles the case where it is safe to use @c
+ * tuple_element.
+ * @endif
+ */
+ template<int __i, typename _Tuple, bool _IsSafe>
+ struct _Safe_tuple_element_impl
+ : tuple_element<__i, _Tuple> { };
+
+ /**
+ * @if maint
+ * Implementation helper for _Safe_tuple_element. This partial
+ * specialization handles the case where it is not safe to use @c
+ * tuple_element. We just return @c _No_tuple_element.
+ * @endif
+ */
+ template<int __i, typename _Tuple>
+ struct _Safe_tuple_element_impl<__i, _Tuple, false>
+ {
+ typedef _No_tuple_element type;
+ };
+
+ /**
+ * Like tuple_element, but returns @c _No_tuple_element when
+ * tuple_element would return an error.
+ */
+ template<int __i, typename _Tuple>
+ struct _Safe_tuple_element
+ : _Safe_tuple_element_impl<__i, _Tuple,
+ (__i >= 0 && __i < tuple_size<_Tuple>::value)>
+ {
+ };
+
+ /**
+ * @if maint
+ * Maps an argument to bind() into an actual argument to the bound
+ * function object [TR1 3.6.3/5]. Only the first parameter should
+ * be specified: the rest are used to determine among the various
+ * implementations. Note that, although this class is a function
+ * object, isn't not entirely normal because it takes only two
+ * parameters regardless of the number of parameters passed to the
+ * bind expression. The first parameter is the bound argument and
+ * the second parameter is a tuple containing references to the
+ * rest of the arguments.
+ * @endif
+ */
+ template<typename _Arg,
+ bool _IsBindExp = is_bind_expression<_Arg>::value,
+ bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+ class _Mu;
+
+ /**
+ * @if maint
+ * If the argument is reference_wrapper<_Tp>, returns the
+ * underlying reference. [TR1 3.6.3/5 bullet 1]
+ * @endif
+ */
+ template<typename _Tp>
+ class _Mu<reference_wrapper<_Tp>, false, false>
+ {
+ public:
+ typedef _Tp& result_type;
+
+ /* Note: This won't actually work for const volatile
+ * reference_wrappers, because reference_wrapper::get() is const
+ * but not volatile-qualified. This might be a defect in the TR.
+ */
+ template<typename _CVRef, typename _Tuple>
+ result_type
+ operator()(_CVRef& __arg, const _Tuple&) const volatile
+ { return __arg.get(); }
+ };
+
+ /**
+ * @if maint
+ * If the argument is a bind expression, we invoke the underlying
+ * function object with the same cv-qualifiers as we are given and
+ * pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
+ * @endif
+ */
+ template<typename _Arg>
+ class _Mu<_Arg, true, false>
+ {
+ public:
+ template<typename _Signature> class result;
+
+ // Determine the result type when we pass the arguments along. This
+ // involves passing along the cv-qualifiers placed on _Mu and
+ // unwrapping the argument bundle.
+ template<typename _CVMu, typename _CVArg, typename... _Args>
+ class result<_CVMu(_CVArg, tuple<_Args...>)>
+ : public result_of<_CVArg(_Args...)> { };
+
+ template<typename _CVArg, typename... _Args>
+ typename result_of<_CVArg(_Args...)>::type
+ operator()(_CVArg& __arg,
+ const tuple<_Args...>& __tuple) const volatile
+ {
+ // Construct an index tuple and forward to __call
+ typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+ _Indexes;
+ return this->__call(__arg, __tuple, _Indexes());
+ }
+
+ private:
+ // Invokes the underlying function object __arg by unpacking all
+ // of the arguments in the tuple.
+ template<typename _CVArg, typename... _Args, int... _Indexes>
+ typename result_of<_CVArg(_Args...)>::type
+ __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
+ const _Index_tuple<_Indexes...>&) const volatile
+ {
+ return __arg(_GLIBCXX_TR1 get<_Indexes>(__tuple)...);
+ }
+ };
+
+ /**
+ * @if maint
+ * If the argument is a placeholder for the Nth argument, returns
+ * a reference to the Nth argument to the bind function object.
+ * [TR1 3.6.3/5 bullet 3]
+ * @endif
+ */
+ template<typename _Arg>
+ class _Mu<_Arg, false, true>
+ {
+ public:
+ template<typename _Signature> class result;
+
+ template<typename _CVMu, typename _CVArg, typename _Tuple>
+ class result<_CVMu(_CVArg, _Tuple)>
+ {
+ // Add a reference, if it hasn't already been done for us.
+ // This allows us to be a little bit sloppy in constructing
+ // the tuple that we pass to result_of<...>.
+ typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
+ - 1), _Tuple>::type
+ __base_type;
+
+ public:
+ typedef typename add_reference<__base_type>::type type;
+ };
+
+ template<typename _Tuple>
+ typename result<_Mu(_Arg, _Tuple)>::type
+ operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
+ {
+ return ::std::_GLIBCXX_TR1 get<(is_placeholder<_Arg>::value
+ - 1)>(__tuple);
+ }
+ };
+
+ /**
+ * @if maint
+ * If the argument is just a value, returns a reference to that
+ * value. The cv-qualifiers on the reference are the same as the
+ * cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
+ * @endif
+ */
+ template<typename _Arg>
+ class _Mu<_Arg, false, false>
+ {
+ public:
+ template<typename _Signature> struct result;
+
+ template<typename _CVMu, typename _CVArg, typename _Tuple>
+ struct result<_CVMu(_CVArg, _Tuple)>
+ {
+ typedef typename add_reference<_CVArg>::type type;
+ };
+
+ // Pick up the cv-qualifiers of the argument
+ template<typename _CVArg, typename _Tuple>
+ _CVArg&
+ operator()(_CVArg& __arg, const _Tuple&) const volatile
+ { return __arg; }
+ };
+
+ /**
+ * @if maint
+ * Maps member pointers into instances of _Mem_fn but leaves all
+ * other function objects untouched. Used by tr1::bind(). The
+ * primary template handles the non--member-pointer case.
+ * @endif
+ */
+ template<typename _Tp>
+ struct _Maybe_wrap_member_pointer
+ {
+ typedef _Tp type;
+
+ static const _Tp&
+ __do_wrap(const _Tp& __x)
+ { return __x; }
+ };
+
+ /**
+ * @if maint
+ * Maps member pointers into instances of _Mem_fn but leaves all
+ * other function objects untouched. Used by tr1::bind(). This
+ * partial specialization handles the member pointer case.
+ * @endif
+ */
+ template<typename _Tp, typename _Class>
+ struct _Maybe_wrap_member_pointer<_Tp _Class::*>
+ {
+ typedef _Mem_fn<_Tp _Class::*> type;
+
+ static type
+ __do_wrap(_Tp _Class::* __pm)
+ { return type(__pm); }
+ };
+
+ /**
+ * @if maint
+ * Type of the function object returned from bind().
+ * @endif
+ */
+ template<typename _Signature>
+ struct _Bind;
+
+ template<typename _Functor, typename... _Bound_args>
+ class _Bind<_Functor(_Bound_args...)>
+ : public _Weak_result_type<_Functor>
+ {
+ typedef _Bind __self_type;
+ typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+ _Functor _M_f;
+ tuple<_Bound_args...> _M_bound_args;
+
+ // Call unqualified
+ template<typename... _Args, int... _Indexes>
+ typename result_of<
+ _Functor(typename result_of<_Mu<_Bound_args>
+ (_Bound_args, tuple<_Args...>)>::type...)
+ >::type
+ __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ // Call as const
+ template<typename... _Args, int... _Indexes>
+ typename result_of<
+ const _Functor(typename result_of<_Mu<_Bound_args>
+ (const _Bound_args, tuple<_Args...>)
+ >::type...)>::type
+ __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ // Call as volatile
+ template<typename... _Args, int... _Indexes>
+ typename result_of<
+ volatile _Functor(typename result_of<_Mu<_Bound_args>
+ (volatile _Bound_args, tuple<_Args...>)
+ >::type...)>::type
+ __call(const tuple<_Args...>& __args,
+ _Index_tuple<_Indexes...>) volatile
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ // Call as const volatile
+ template<typename... _Args, int... _Indexes>
+ typename result_of<
+ const volatile _Functor(typename result_of<_Mu<_Bound_args>
+ (const volatile _Bound_args,
+ tuple<_Args...>)
+ >::type...)>::type
+ __call(const tuple<_Args...>& __args,
+ _Index_tuple<_Indexes...>) const volatile
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ public:
+ explicit _Bind(_Functor __f, _Bound_args... __bound_args)
+ : _M_f(__f), _M_bound_args(__bound_args...) { }
+
+ // Call unqualified
+ template<typename... _Args>
+ typename result_of<
+ _Functor(typename result_of<_Mu<_Bound_args>
+ (_Bound_args, tuple<_Args...>)>::type...)
+ >::type
+ operator()(_Args&... __args)
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+
+ // Call as const
+ template<typename... _Args>
+ typename result_of<
+ const _Functor(typename result_of<_Mu<_Bound_args>
+ (const _Bound_args, tuple<_Args...>)>::type...)
+ >::type
+ operator()(_Args&... __args) const
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+
+
+ // Call as volatile
+ template<typename... _Args>
+ typename result_of<
+ volatile _Functor(typename result_of<_Mu<_Bound_args>
+ (volatile _Bound_args, tuple<_Args...>)>::type...)
+ >::type
+ operator()(_Args&... __args) volatile
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+
+
+ // Call as const volatile
+ template<typename... _Args>
+ typename result_of<
+ const volatile _Functor(typename result_of<_Mu<_Bound_args>
+ (const volatile _Bound_args,
+ tuple<_Args...>)>::type...)
+ >::type
+ operator()(_Args&... __args) const volatile
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+ };
+
+ /**
+ * @if maint
+ * Type of the function object returned from bind<R>().
+ * @endif
+ */
+ template<typename _Result, typename _Signature>
+ struct _Bind_result;
+
+ template<typename _Result, typename _Functor, typename... _Bound_args>
+ class _Bind_result<_Result, _Functor(_Bound_args...)>
+ {
+ typedef _Bind_result __self_type;
+ typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+ _Functor _M_f;
+ tuple<_Bound_args...> _M_bound_args;
+
+ // Call unqualified
+ template<typename... _Args, int... _Indexes>
+ _Result
+ __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ // Call as const
+ template<typename... _Args, int... _Indexes>
+ _Result
+ __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ // Call as volatile
+ template<typename... _Args, int... _Indexes>
+ _Result
+ __call(const tuple<_Args...>& __args,
+ _Index_tuple<_Indexes...>) volatile
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ // Call as const volatile
+ template<typename... _Args, int... _Indexes>
+ _Result
+ __call(const tuple<_Args...>& __args,
+ _Index_tuple<_Indexes...>) const volatile
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+ public:
+ typedef _Result result_type;
+
+ explicit
+ _Bind_result(_Functor __f, _Bound_args... __bound_args)
+ : _M_f(__f), _M_bound_args(__bound_args...) { }
+
+ // Call unqualified
+ template<typename... _Args>
+ result_type
+ operator()(_Args&... __args)
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+
+ // Call as const
+ template<typename... _Args>
+ result_type
+ operator()(_Args&... __args) const
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+
+ // Call as volatile
+ template<typename... _Args>
+ result_type
+ operator()(_Args&... __args) volatile
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+
+ // Call as const volatile
+ template<typename... _Args>
+ result_type
+ operator()(_Args&... __args) const volatile
+ {
+ return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
+ }
+ };
+
+ /**
+ * @if maint
+ * Class template _Bind is always a bind expression.
+ * @endif
+ */
+ template<typename _Signature>
+ struct is_bind_expression<_Bind<_Signature> >
+ { static const bool value = true; };
+
+ template<typename _Signature>
+ const bool is_bind_expression<_Bind<_Signature> >::value;
+
+ /**
+ * @if maint
+ * Class template _Bind_result is always a bind expression.
+ * @endif
+ */
+ template<typename _Result, typename _Signature>
+ struct is_bind_expression<_Bind_result<_Result, _Signature> >
+ { static const bool value = true; };
+
+ template<typename _Result, typename _Signature>
+ const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value;
+
+ template<typename _Functor, typename... _ArgTypes>
+ inline
+ _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)>
+ bind(_Functor __f, _ArgTypes... __args)
+ {
+ typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
+ typedef typename __maybe_type::type __functor_type;
+ typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
+ return __result_type(__maybe_type::__do_wrap(__f), __args...);
+ }
+
+ template<typename _Result, typename _Functor, typename... _ArgTypes>
+ inline
+ _Bind_result<_Result,
+ typename _Maybe_wrap_member_pointer<_Functor>::type
+ (_ArgTypes...)>
+ bind(_Functor __f, _ArgTypes... __args)
+ {
+ typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
+ typedef typename __maybe_type::type __functor_type;
+ typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
+ __result_type;
+ return __result_type(__maybe_type::__do_wrap(__f), __args...);
+ }
+
+ /**
+ * @brief Exception class thrown when class template function's
+ * operator() is called with an empty target.
+ *
+ */
+ class bad_function_call : public std::exception { };
+
+ /**
+ * @if maint
+ * The integral constant expression 0 can be converted into a
+ * pointer to this type. It is used by the function template to
+ * accept NULL pointers.
+ * @endif
+ */
+ struct _M_clear_type;
+
+ /**
+ * @if maint
+ * Trait identifying "location-invariant" types, meaning that the
+ * address of the object (or any of its members) will not escape.
+ * Also implies a trivial copy constructor and assignment operator.
+ * @endif
+ */
+ template<typename _Tp>
+ struct __is_location_invariant
+ : integral_constant<bool,
+ (is_pointer<_Tp>::value
+ || is_member_pointer<_Tp>::value)>
+ {
+ };
+
+ class _Undefined_class;
+
+ union _Nocopy_types
+ {
+ void* _M_object;
+ const void* _M_const_object;
+ void (*_M_function_pointer)();
+ void (_Undefined_class::*_M_member_pointer)();
+ };
+
+ union _Any_data
+ {
+ void* _M_access() { return &_M_pod_data[0]; }
+ const void* _M_access() const { return &_M_pod_data[0]; }
+
+ template<typename _Tp>
+ _Tp&
+ _M_access()
+ { return *static_cast<_Tp*>(_M_access()); }
+
+ template<typename _Tp>
+ const _Tp&
+ _M_access() const
+ { return *static_cast<const _Tp*>(_M_access()); }
+
+ _Nocopy_types _M_unused;
+ char _M_pod_data[sizeof(_Nocopy_types)];
+ };
+
+ enum _Manager_operation
+ {
+ __get_type_info,
+ __get_functor_ptr,
+ __clone_functor,
+ __destroy_functor
+ };
+
+ /* Simple type wrapper that helps avoid annoying const problems
+ when casting between void pointers and pointers-to-pointers. */
+ template<typename _Tp>
+ struct _Simple_type_wrapper
+ {
+ _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+
+ _Tp __value;
+ };
+
+ template<typename _Tp>
+ struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+ : __is_location_invariant<_Tp>
+ {
+ };
+
+ // Converts a reference to a function object into a callable
+ // function object.
+ template<typename _Functor>
+ inline _Functor&
+ __callable_functor(_Functor& __f)
+ { return __f; }
+
+ template<typename _Member, typename _Class>
+ inline _Mem_fn<_Member _Class::*>
+ __callable_functor(_Member _Class::* &__p)
+ { return mem_fn(__p); }
+
+ template<typename _Member, typename _Class>
+ inline _Mem_fn<_Member _Class::*>
+ __callable_functor(_Member _Class::* const &__p)
+ { return mem_fn(__p); }
+
+ template<typename _Signature>
+ class function;
+
+ /**
+ * @if maint
+ * Base class of all polymorphic function object wrappers.
+ * @endif
+ */
+ class _Function_base
+ {
+ public:
+ static const std::size_t _M_max_size = sizeof(_Nocopy_types);
+ static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
+
+ template<typename _Functor>
+ class _Base_manager
+ {
+ protected:
+ static const bool __stored_locally =
+ (__is_location_invariant<_Functor>::value
+ && sizeof(_Functor) <= _M_max_size
+ && __alignof__(_Functor) <= _M_max_align
+ && (_M_max_align % __alignof__(_Functor) == 0));
+
+ typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+ // Retrieve a pointer to the function object
+ static _Functor*
+ _M_get_pointer(const _Any_data& __source)
+ {
+ const _Functor* __ptr =
+ __stored_locally? &__source._M_access<_Functor>()
+ /* have stored a pointer */ : __source._M_access<_Functor*>();
+ return const_cast<_Functor*>(__ptr);
+ }
+
+ // Clone a location-invariant function object that fits within
+ // an _Any_data structure.
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+ {
+ new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+ }
+
+ // Clone a function object that is not location-invariant or
+ // that cannot fit into an _Any_data structure.
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+ {
+ __dest._M_access<_Functor*>() =
+ new _Functor(*__source._M_access<_Functor*>());
+ }
+
+ // Destroying a location-invariant object may still require
+ // destruction.
+ static void
+ _M_destroy(_Any_data& __victim, true_type)
+ {
+ __victim._M_access<_Functor>().~_Functor();
+ }
+
+ // Destroying an object located on the heap.
+ static void
+ _M_destroy(_Any_data& __victim, false_type)
+ {
+ delete __victim._M_access<_Functor*>();
+ }
+
+ public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+ _Manager_operation __op)
+ {
+ switch (__op)
+ {
+ case __get_type_info:
+ __dest._M_access<const type_info*>() = &typeid(_Functor);
+ break;
+
+ case __get_functor_ptr:
+ __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+ break;
+
+ case __clone_functor:
+ _M_clone(__dest, __source, _Local_storage());
+ break;
+
+ case __destroy_functor:
+ _M_destroy(__dest, _Local_storage());
+ break;
+ }
+ return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, const _Functor& __f)
+ {
+ _M_init_functor(__functor, __f, _Local_storage());
+ }
+
+ template<typename _Signature>
+ static bool
+ _M_not_empty_function(const function<_Signature>& __f)
+ {
+ return __f;
+ }
+
+ template<typename _Tp>
+ static bool
+ _M_not_empty_function(const _Tp*& __fp)
+ {
+ return __fp;
+ }
+
+ template<typename _Class, typename _Tp>
+ static bool
+ _M_not_empty_function(_Tp _Class::* const& __mp)
+ {
+ return __mp;
+ }
+
+ template<typename _Tp>
+ static bool
+ _M_not_empty_function(const _Tp&)
+ {
+ return true;
+ }
+
+ private:
+ static void
+ _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
+ {
+ new (__functor._M_access()) _Functor(__f);
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
+ {
+ __functor._M_access<_Functor*>() = new _Functor(__f);
+ }
+ };
+
+ template<typename _Functor>
+ class _Ref_manager : public _Base_manager<_Functor*>
+ {
+ typedef _Function_base::_Base_manager<_Functor*> _Base;
+
+ public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+ _Manager_operation __op)
+ {
+ switch (__op)
+ {
+ case __get_type_info:
+ __dest._M_access<const type_info*>() = &typeid(_Functor);
+ break;
+
+ case __get_functor_ptr:
+ __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
+ return is_const<_Functor>::value;
+ break;
+
+ default:
+ _Base::_M_manager(__dest, __source, __op);
+ }
+ return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
+ {
+ // TBD: Use address_of function instead
+ _Base::_M_init_functor(__functor, &__f.get());
+ }
+ };
+
+ _Function_base() : _M_manager(0) { }
+
+ ~_Function_base()
+ {
+ if (_M_manager)
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+ }
+
+
+ bool _M_empty() const { return !_M_manager; }
+
+ typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+ _Manager_operation);
+
+ _Any_data _M_functor;
+ _Manager_type _M_manager;
+ };
+
+ template<typename _Signature, typename _Functor>
+ class _Function_handler;
+
+ template<typename _Res, typename _Functor, typename... _ArgTypes>
+ class _Function_handler<_Res(_ArgTypes...), _Functor>
+ : public _Function_base::_Base_manager<_Functor>
+ {
+ typedef _Function_base::_Base_manager<_Functor> _Base;
+
+ public:
+ static _Res
+ _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+ {
+ return (*_Base::_M_get_pointer(__functor))(__args...);
+ }
+ };
+
+ template<typename _Functor, typename... _ArgTypes>
+ class _Function_handler<void(_ArgTypes...), _Functor>
+ : public _Function_base::_Base_manager<_Functor>
+ {
+ typedef _Function_base::_Base_manager<_Functor> _Base;
+
+ public:
+ static void
+ _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+ {
+ (*_Base::_M_get_pointer(__functor))(__args...);
+ }
+ };
+
+ template<typename _Res, typename _Functor, typename... _ArgTypes>
+ class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
+ : public _Function_base::_Ref_manager<_Functor>
+ {
+ typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+ public:
+ static _Res
+ _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+ {
+ return
+ __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+ }
+ };
+
+ template<typename _Functor, typename... _ArgTypes>
+ class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
+ : public _Function_base::_Ref_manager<_Functor>
+ {
+ typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+ public:
+ static void
+ _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+ {
+ __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+ }
+ };
+
+ template<typename _Class, typename _Member, typename _Res,
+ typename... _ArgTypes>
+ class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
+ : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ {
+ typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ _Base;
+
+ public:
+ static _Res
+ _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+ {
+ return _GLIBCXX_TR1
+ mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+ }
+ };
+
+ template<typename _Class, typename _Member, typename... _ArgTypes>
+ class _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ : public _Function_base::_Base_manager<
+ _Simple_type_wrapper< _Member _Class::* > >
+ {
+ typedef _Member _Class::* _Functor;
+ typedef _Simple_type_wrapper<_Functor> _Wrapper;
+ typedef _Function_base::_Base_manager<_Wrapper> _Base;
+
+ public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+ _Manager_operation __op)
+ {
+ switch (__op)
+ {
+ case __get_type_info:
+ __dest._M_access<const type_info*>() = &typeid(_Functor);
+ break;
+
+ case __get_functor_ptr:
+ __dest._M_access<_Functor*>() =
+ &_Base::_M_get_pointer(__source)->__value;
+ break;
+
+ default:
+ _Base::_M_manager(__dest, __source, __op);
+ }
+ return false;
+ }
+
+ static void
+ _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+ {
+ _GLIBCXX_TR1
+ mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+ }
+ };
+
+ template<typename _Res, typename... _ArgTypes>
+ class function<_Res(_ArgTypes...)>
+ : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+ private _Function_base
+ {
+ /**
+ * @if maint
+ * This class is used to implement the safe_bool idiom.
+ * @endif
+ */
+ struct _Hidden_type
+ {
+ _Hidden_type* _M_bool;
+ };
+
+ /**
+ * @if maint
+ * This typedef is used to implement the safe_bool idiom.
+ * @endif
+ */
+ typedef _Hidden_type* _Hidden_type::* _Safe_bool;
+
+ typedef _Res _Signature_type(_ArgTypes...);
+
+ struct _Useless {};
+
+ public:
+ typedef _Res result_type;
+
+ // [3.7.2.1] construct/copy/destroy
+
+ /**
+ * @brief Default construct creates an empty function call wrapper.
+ * @post @c !(bool)*this
+ */
+ function() : _Function_base() { }
+
+ /**
+ * @brief Default construct creates an empty function call wrapper.
+ * @post @c !(bool)*this
+ */
+ function(_M_clear_type*) : _Function_base() { }
+
+ /**
+ * @brief %Function copy constructor.
+ * @param x A %function object with identical call signature.
+ * @pre @c (bool)*this == (bool)x
+ *
+ * The newly-created %function contains a copy of the target of @a
+ * x (if it has one).
+ */
+ function(const function& __x);
+
+ /**
+ * @brief Builds a %function that targets a copy of the incoming
+ * function object.
+ * @param f A %function object that is callable with parameters of
+ * type @c T1, @c T2, ..., @c TN and returns a value convertible
+ * to @c Res.
+ *
+ * The newly-created %function object will target a copy of @a
+ * f. If @a f is @c reference_wrapper<F>, then this function
+ * object will contain a reference to the function object @c
+ * f.get(). If @a f is a NULL function pointer or NULL
+ * pointer-to-member, the newly-created object will be empty.
+ *
+ * If @a f is a non-NULL function pointer or an object of type @c
+ * reference_wrapper<F>, this function will not throw.
+ */
+ template<typename _Functor>
+ function(_Functor __f,
+ typename __gnu_cxx::__enable_if<
+ !is_integral<_Functor>::value, _Useless>::__type
+ = _Useless());
+
+ /**
+ * @brief %Function assignment operator.
+ * @param x A %function with identical call signature.
+ * @post @c (bool)*this == (bool)x
+ * @returns @c *this
+ *
+ * The target of @a x is copied to @c *this. If @a x has no
+ * target, then @c *this will be empty.
+ *
+ * If @a x targets a function pointer or a reference to a function
+ * object, then this operation will not throw an exception.
+ */
+ function&
+ operator=(const function& __x)
+ {
+ function(__x).swap(*this);
+ return *this;
+ }
+
+ /**
+ * @brief %Function assignment to zero.
+ * @post @c !(bool)*this
+ * @returns @c *this
+ *
+ * The target of @a *this is deallocated, leaving it empty.
+ */
+ function&
+ operator=(_M_clear_type*)
+ {
+ if (_M_manager)
+ {
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+ _M_manager = 0;
+ _M_invoker = 0;
+ }
+ return *this;
+ }
+
+ /**
+ * @brief %Function assignment to a new target.
+ * @param f A %function object that is callable with parameters of
+ * type @c T1, @c T2, ..., @c TN and returns a value convertible
+ * to @c Res.
+ * @return @c *this
+ *
+ * This %function object wrapper will target a copy of @a
+ * f. If @a f is @c reference_wrapper<F>, then this function
+ * object will contain a reference to the function object @c
+ * f.get(). If @a f is a NULL function pointer or NULL
+ * pointer-to-member, @c this object will be empty.
+ *
+ * If @a f is a non-NULL function pointer or an object of type @c
+ * reference_wrapper<F>, this function will not throw.
+ */
+ template<typename _Functor>
+ typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
+ function&>::__type
+ operator=(_Functor __f)
+ {
+ function(__f).swap(*this);
+ return *this;
+ }
+
+ // [3.7.2.2] function modifiers
+
+ /**
+ * @brief Swap the targets of two %function objects.
+ * @param f A %function with identical call signature.
+ *
+ * Swap the targets of @c this function object and @a f. This
+ * function will not throw an exception.
+ */
+ void swap(function& __x)
+ {
+ _Any_data __old_functor = _M_functor;
+ _M_functor = __x._M_functor;
+ __x._M_functor = __old_functor;
+ _Manager_type __old_manager = _M_manager;
+ _M_manager = __x._M_manager;
+ __x._M_manager = __old_manager;
+ _Invoker_type __old_invoker = _M_invoker;
+ _M_invoker = __x._M_invoker;
+ __x._M_invoker = __old_invoker;
+ }
+
+ // [3.7.2.3] function capacity
+
+ /**
+ * @brief Determine if the %function wrapper has a target.
+ *
+ * @return @c true when this %function object contains a target,
+ * or @c false when it is empty.
+ *
+ * This function will not throw an exception.
+ */
+ operator _Safe_bool() const
+ {
+ if (_M_empty())
+ return 0;
+ else
+ return &_Hidden_type::_M_bool;
+ }
+
+ // [3.7.2.4] function invocation
+
+ /**
+ * @brief Invokes the function targeted by @c *this.
+ * @returns the result of the target.
+ * @throws bad_function_call when @c !(bool)*this
+ *
+ * The function call operator invokes the target function object
+ * stored by @c this.
+ */
+ _Res operator()(_ArgTypes... __args) const;
+
+ // [3.7.2.5] function target access
+ /**
+ * @brief Determine the type of the target of this function object
+ * wrapper.
+ *
+ * @returns the type identifier of the target function object, or
+ * @c typeid(void) if @c !(bool)*this.
+ *
+ * This function will not throw an exception.
+ */
+ const type_info& target_type() const;
+
+ /**
+ * @brief Access the stored target function object.
+ *
+ * @return Returns a pointer to the stored target function object,
+ * if @c typeid(Functor).equals(target_type()); otherwise, a NULL
+ * pointer.
+ *
+ * This function will not throw an exception.
+ */
+ template<typename _Functor> _Functor* target();
+
+ /**
+ * @overload
+ */
+ template<typename _Functor> const _Functor* target() const;
+
+ private:
+ // [3.7.2.6] undefined operators
+ template<typename _Function>
+ void operator==(const function<_Function>&) const;
+ template<typename _Function>
+ void operator!=(const function<_Function>&) const;
+
+ typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
+ _Invoker_type _M_invoker;
+ };
+
+ template<typename _Res, typename... _ArgTypes>
+ function<_Res(_ArgTypes...)>::
+ function(const function& __x)
+ : _Function_base()
+ {
+ if (__x)
+ {
+ _M_invoker = __x._M_invoker;
+ _M_manager = __x._M_manager;
+ __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+ }
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ template<typename _Functor>
+ function<_Res(_ArgTypes...)>::
+ function(_Functor __f,
+ typename __gnu_cxx::__enable_if<
+ !is_integral<_Functor>::value, _Useless>::__type)
+ : _Function_base()
+ {
+ typedef _Function_handler<_Signature_type, _Functor> _My_handler;
+
+ if (_My_handler::_M_not_empty_function(__f))
+ {
+ _M_invoker = &_My_handler::_M_invoke;
+ _M_manager = &_My_handler::_M_manager;
+ _My_handler::_M_init_functor(_M_functor, __f);
+ }
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ _Res
+ function<_Res(_ArgTypes...)>::
+ operator()(_ArgTypes... __args) const
+ {
+ if (_M_empty())
+ {
+#if __EXCEPTIONS
+ throw bad_function_call();
+#else
+ __builtin_abort();
+#endif
+ }
+ return _M_invoker(_M_functor, __args...);
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ const type_info&
+ function<_Res(_ArgTypes...)>::
+ target_type() const
+ {
+ if (_M_manager)
+ {
+ _Any_data __typeinfo_result;
+ _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+ return *__typeinfo_result._M_access<const type_info*>();
+ }
+ else
+ return typeid(void);
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ template<typename _Functor>
+ _Functor*
+ function<_Res(_ArgTypes...)>::
+ target()
+ {
+ if (typeid(_Functor) == target_type() && _M_manager)
+ {
+ _Any_data __ptr;
+ if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
+ && !is_const<_Functor>::value)
+ return 0;
+ else
+ return __ptr._M_access<_Functor*>();
+ }
+ else
+ return 0;
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ template<typename _Functor>
+ const _Functor*
+ function<_Res(_ArgTypes...)>::
+ target() const
+ {
+ if (typeid(_Functor) == target_type() && _M_manager)
+ {
+ _Any_data __ptr;
+ _M_manager(__ptr, _M_functor, __get_functor_ptr);
+ return __ptr._M_access<const _Functor*>();
+ }
+ else
+ return 0;
+ }
+
+ // [3.7.2.7] null pointer comparisons
+
+ /**
+ * @brief Compares a polymorphic function object wrapper against 0
+ * (the NULL pointer).
+ * @returns @c true if the wrapper has no target, @c false otherwise
+ *
+ * This function will not throw an exception.
+ */
+ template<typename _Signature>
+ inline bool
+ operator==(const function<_Signature>& __f, _M_clear_type*)
+ {
+ return !__f;
+ }
+
+ /**
+ * @overload
+ */
+ template<typename _Signature>
+ inline bool
+ operator==(_M_clear_type*, const function<_Signature>& __f)
+ {
+ return !__f;
+ }
+
+ /**
+ * @brief Compares a polymorphic function object wrapper against 0
+ * (the NULL pointer).
+ * @returns @c false if the wrapper has no target, @c true otherwise
+ *
+ * This function will not throw an exception.
+ */
+ template<typename _Signature>
+ inline bool
+ operator!=(const function<_Signature>& __f, _M_clear_type*)
+ {
+ return __f;
+ }
+
+ /**
+ * @overload
+ */
+ template<typename _Signature>
+ inline bool
+ operator!=(_M_clear_type*, const function<_Signature>& __f)
+ {
+ return __f;
+ }
+
+ // [3.7.2.8] specialized algorithms
+
+ /**
+ * @brief Swap the targets of two polymorphic function object wrappers.
+ *
+ * This function will not throw an exception.
+ */
+ template<typename _Signature>
+ inline void
+ swap(function<_Signature>& __x, function<_Signature>& __y)
+ {
+ __x.swap(__y);
+ }
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// TR1 functional -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/functional_hash.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // Definition of default hash function std::tr1::hash<>. The types for
+ // which std::tr1::hash<T> is defined is in clause 6.3.3. of the PDTR.
+ template<typename _Tp>
+ struct hash;
+
+#define _TR1_hashtable_define_trivial_hash(_Tp) \
+ template<> \
+ struct hash<_Tp> \
+ : public std::unary_function<_Tp, std::size_t> \
+ { \
+ std::size_t \
+ operator()(_Tp __val) const \
+ { return static_cast<std::size_t>(__val); } \
+ }
+
+ _TR1_hashtable_define_trivial_hash(bool);
+ _TR1_hashtable_define_trivial_hash(char);
+ _TR1_hashtable_define_trivial_hash(signed char);
+ _TR1_hashtable_define_trivial_hash(unsigned char);
+ _TR1_hashtable_define_trivial_hash(wchar_t);
+ _TR1_hashtable_define_trivial_hash(short);
+ _TR1_hashtable_define_trivial_hash(int);
+ _TR1_hashtable_define_trivial_hash(long);
+ _TR1_hashtable_define_trivial_hash(long long);
+ _TR1_hashtable_define_trivial_hash(unsigned short);
+ _TR1_hashtable_define_trivial_hash(unsigned int);
+ _TR1_hashtable_define_trivial_hash(unsigned long);
+ _TR1_hashtable_define_trivial_hash(unsigned long long);
+
+#undef _TR1_hashtable_define_trivial_hash
+
+ template<typename _Tp>
+ struct hash<_Tp*>
+ : public std::unary_function<_Tp*, std::size_t>
+ {
+ std::size_t
+ operator()(_Tp* __p) const
+ { return reinterpret_cast<std::size_t>(__p); }
+ };
+
+ // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
+ // (used by the next specializations of std::tr1::hash<>)
+
+ // Dummy generic implementation (for sizeof(size_t) != 4, 8).
+ template<std::size_t = sizeof(std::size_t)>
+ struct _Fnv_hash
+ {
+ static std::size_t
+ hash(const char* __first, std::size_t __length)
+ {
+ std::size_t __result = 0;
+ for (; __length > 0; --__length)
+ __result = (__result * 131) + *__first++;
+ return __result;
+ }
+ };
+
+ template<>
+ struct _Fnv_hash<4>
+ {
+ static std::size_t
+ hash(const char* __first, std::size_t __length)
+ {
+ std::size_t __result = static_cast<std::size_t>(2166136261UL);
+ for (; __length > 0; --__length)
+ {
+ __result ^= static_cast<std::size_t>(*__first++);
+ __result *= static_cast<std::size_t>(16777619UL);
+ }
+ return __result;
+ }
+ };
+
+ template<>
+ struct _Fnv_hash<8>
+ {
+ static std::size_t
+ hash(const char* __first, std::size_t __length)
+ {
+ std::size_t __result =
+ static_cast<std::size_t>(14695981039346656037ULL);
+ for (; __length > 0; --__length)
+ {
+ __result ^= static_cast<std::size_t>(*__first++);
+ __result *= static_cast<std::size_t>(1099511628211ULL);
+ }
+ return __result;
+ }
+ };
+
+ // XXX String and floating point hashes probably shouldn't be inline
+ // member functions, since are nontrivial. Once we have the framework
+ // for TR1 .cc files, these should go in one.
+ template<>
+ struct hash<std::string>
+ : public std::unary_function<std::string, std::size_t>
+ {
+ std::size_t
+ operator()(const std::string& __s) const
+ { return _Fnv_hash<>::hash(__s.data(), __s.length()); }
+ };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+ template<>
+ struct hash<std::wstring>
+ : public std::unary_function<std::wstring, std::size_t>
+ {
+ std::size_t
+ operator()(const std::wstring& __s) const
+ {
+ return _Fnv_hash<>::hash(reinterpret_cast<const char*>(__s.data()),
+ __s.length() * sizeof(wchar_t));
+ }
+ };
+#endif
+
+ template<>
+ struct hash<float>
+ : public std::unary_function<float, std::size_t>
+ {
+ std::size_t
+ operator()(float __fval) const
+ {
+ std::size_t __result = 0;
+
+ // 0 and -0 both hash to zero.
+ if (__fval != 0.0f)
+ __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__fval),
+ sizeof(__fval));
+ return __result;
+ }
+ };
+
+ template<>
+ struct hash<double>
+ : public std::unary_function<double, std::size_t>
+ {
+ std::size_t
+ operator()(double __dval) const
+ {
+ std::size_t __result = 0;
+
+ // 0 and -0 both hash to zero.
+ if (__dval != 0.0)
+ __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__dval),
+ sizeof(__dval));
+ return __result;
+ }
+ };
+
+ // For long double, careful with random padding bits (e.g., on x86,
+ // 10 bytes -> 12 bytes) and resort to frexp.
+ template<>
+ struct hash<long double>
+ : public std::unary_function<long double, std::size_t>
+ {
+ std::size_t
+ operator()(long double __ldval) const
+ {
+ std::size_t __result = 0;
+
+ int __exponent;
+ __ldval = std::frexp(__ldval, &__exponent);
+ __ldval = __ldval < 0.0l ? -(__ldval + 0.5l) : __ldval;
+
+ const long double __mult =
+ __gnu_cxx::__numeric_traits<std::size_t>::__max + 1.0l;
+ __ldval *= __mult;
+
+ // Try to use all the bits of the mantissa (really necessary only
+ // on 32-bit targets, at least for 80-bit floating point formats).
+ const std::size_t __hibits = (std::size_t)__ldval;
+ __ldval = (__ldval - (long double)__hibits) * __mult;
+
+ const std::size_t __coeff =
+ __gnu_cxx::__numeric_traits<std::size_t>::__max / __LDBL_MAX_EXP__;
+
+ __result = __hibits + (std::size_t)__ldval + __coeff * __exponent;
+
+ return __result;
+ }
+ };
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
// Internal header for TR1 unordered_set and unordered_map -*- C++ -*-
-// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
-/** @file tr1/hashtable
- * This is a TR1 C++ Library header.
+/** @file tr1_impl/hashtable
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
*/
// This header file defines std::tr1::hashtable, which is used to
// A. Tavori and V. Dreizin, "Policy-Based Data Structures", 2004.
// http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/index.html
-#ifndef _TR1_HASHTABLE
-#define _TR1_HASHTABLE 1
-
-#include <utility> // For std::pair
-#include <cstddef>
-#include <cmath>
-#include <bits/stl_iterator_base_types.h>
-#include <bits/stl_iterator_base_funcs.h>
-#include <bits/allocator.h>
-#include <bits/functexcept.h>
-#include <tr1/type_traits> // For true_type and false_type
-#include <tr1/hashtable_policy.h>
+#include <tr1_impl/hashtable_policy.h>
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
// Class template _Hashtable, class definition.
typename _Hashtable::_Hash_code_type);
std::pair<iterator, bool>
- _M_insert(const value_type&, std::_GLIBCXX_TR1::true_type);
+ _M_insert(const value_type&, std::_GLIBCXX_TR1 true_type);
iterator
- _M_insert(const value_type&, std::_GLIBCXX_TR1::false_type);
+ _M_insert(const value_type&, std::_GLIBCXX_TR1 false_type);
void
_M_erase_node(_Node*, _Node**);
// Insert and erase
_Insert_Return_Type
insert(const value_type& __v)
- { return _M_insert(__v, std::_GLIBCXX_TR1::integral_constant<bool,
+ { return _M_insert(__v, std::_GLIBCXX_TR1 integral_constant<bool,
__unique_keys>()); }
iterator
__chc, __cit, __uk>::iterator, bool>
_Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
- _M_insert(const value_type& __v, std::_GLIBCXX_TR1::true_type)
+ _M_insert(const value_type& __v, std::_GLIBCXX_TR1 true_type)
{
const key_type& __k = this->_M_extract(__v);
typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
__chc, __cit, __uk>::iterator
_Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
- _M_insert(const value_type& __v, std::_GLIBCXX_TR1::false_type)
+ _M_insert(const value_type& __v, std::_GLIBCXX_TR1 false_type)
{
std::pair<bool, std::size_t> __do_rehash
= _M_rehash_policy._M_need_rehash(_M_bucket_count,
}
}
-_GLIBCXX_END_NAMESPACE
-} // namespace std::tr1
-
-#endif // _TR1_HASHTABLE
-
+_GLIBCXX_END_NAMESPACE_TR1
+}
// Internal policy header for TR1 unordered_set and unordered_map -*- C++ -*-
-// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
-/** @file tr1/hashtable_policy.h
- * This is a TR1 C++ Library header.
+/** @file tr1_impl/hashtable_policy.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
*/
-#ifndef _TR1_HASHTABLE_POLICY_H
-#define _TR1_HASHTABLE_POLICY_H 1
-
-#include <algorithm> // lower_bound
-#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
-#include <tr1/utility>
-#include <ext/type_traits.h>
-
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
namespace __detail
{
// Helper function: return distance(first, last) for forward
_H2 _M_h2;
};
} // namespace __detail
-_GLIBCXX_END_NAMESPACE
-} // namespace std::tr1
-
-#endif // _TR1_HASHTABLE_POLICY_H
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// random number generation -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/**
+ * @file tr1_impl/random
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // [5.1] Random number generation
+
+ /**
+ * @addtogroup tr1_random Random Number Generation
+ * A facility for generating random numbers on selected distributions.
+ * @{
+ */
+
+ /*
+ * Implementation-space details.
+ */
+ namespace __detail
+ {
+ template<typename _UIntType, int __w,
+ bool = __w < std::numeric_limits<_UIntType>::digits>
+ struct _Shift
+ { static const _UIntType __value = 0; };
+
+ template<typename _UIntType, int __w>
+ struct _Shift<_UIntType, __w, true>
+ { static const _UIntType __value = _UIntType(1) << __w; };
+
+ template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
+ struct _Mod;
+
+ // Dispatch based on modulus value to prevent divide-by-zero compile-time
+ // errors when m == 0.
+ template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
+ inline _Tp
+ __mod(_Tp __x)
+ { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); }
+
+ typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
+ unsigned, unsigned long>::__type _UInt32Type;
+
+ /*
+ * An adaptor class for converting the output of any Generator into
+ * the input for a specific Distribution.
+ */
+ template<typename _Engine, typename _Distribution>
+ struct _Adaptor
+ {
+ typedef typename _Engine::result_type _Engine_result_type;
+ typedef typename _Distribution::input_type result_type;
+
+ public:
+ _Adaptor(const _Engine& __g)
+ : _M_g(__g) { }
+
+ result_type
+ min() const
+ {
+ result_type __return_value = 0;
+ if (is_integral<_Engine_result_type>::value
+ && is_integral<result_type>::value)
+ __return_value = _M_g.min();
+ else if (!is_integral<result_type>::value)
+ __return_value = result_type(0);
+ return __return_value;
+ }
+
+ result_type
+ max() const
+ {
+ result_type __return_value = 0;
+ if (is_integral<_Engine_result_type>::value
+ && is_integral<result_type>::value)
+ __return_value = _M_g.max();
+ else if (!is_integral<result_type>::value)
+ __return_value = result_type(1);
+ return __return_value;
+ }
+
+ result_type
+ operator()();
+
+ private:
+ _Engine _M_g;
+ };
+
+ /*
+ * Converts a value generated by the adapted random number generator into a
+ * value in the input domain for the dependent random number distribution.
+ *
+ * Because the type traits are compile time constants only the appropriate
+ * clause of the if statements will actually be emitted by the compiler.
+ */
+ template<typename _Engine, typename _Distribution>
+ typename _Adaptor<_Engine, _Distribution>::result_type
+ _Adaptor<_Engine, _Distribution>::
+ operator()()
+ {
+ result_type __return_value = 0;
+ if (is_integral<_Engine_result_type>::value
+ && is_integral<result_type>::value)
+ __return_value = _M_g();
+ else if (is_integral<_Engine_result_type>::value
+ && !is_integral<result_type>::value)
+ __return_value = result_type(_M_g() - _M_g.min())
+ / result_type(_M_g.max() - _M_g.min() + result_type(1));
+ else if (!is_integral<_Engine_result_type>::value
+ && !is_integral<result_type>::value)
+ __return_value = result_type(_M_g() - _M_g.min())
+ / result_type(_M_g.max() - _M_g.min());
+ return __return_value;
+ }
+ } // namespace __detail
+
+ /**
+ * Produces random numbers on a given disribution function using a un uniform
+ * random number generation engine.
+ *
+ * @todo the engine_value_type needs to be studied more carefully.
+ */
+ template<typename _Engine, typename _Dist>
+ class variate_generator
+ {
+ // Concept requirements.
+ __glibcxx_class_requires(_Engine, _CopyConstructibleConcept)
+ // __glibcxx_class_requires(_Engine, _EngineConcept)
+ // __glibcxx_class_requires(_Dist, _EngineConcept)
+
+ public:
+ typedef _Engine engine_type;
+ typedef __detail::_Adaptor<_Engine, _Dist> engine_value_type;
+ typedef _Dist distribution_type;
+ typedef typename _Dist::result_type result_type;
+
+ // tr1:5.1.1 table 5.1 requirement
+ typedef typename __gnu_cxx::__enable_if<
+ is_arithmetic<result_type>::value, result_type>::__type _IsValidType;
+
+ /**
+ * Constructs a variate generator with the uniform random number
+ * generator @p __eng for the random distribution @p __dist.
+ *
+ * @throws Any exceptions which may thrown by the copy constructors of
+ * the @p _Engine or @p _Dist objects.
+ */
+ variate_generator(engine_type __eng, distribution_type __dist)
+ : _M_engine(__eng), _M_dist(__dist) { }
+
+ /**
+ * Gets the next generated value on the distribution.
+ */
+ result_type
+ operator()()
+ { return _M_dist(_M_engine); }
+
+ /**
+ * WTF?
+ */
+ template<typename _Tp>
+ result_type
+ operator()(_Tp __value)
+ { return _M_dist(_M_engine, __value); }
+
+ /**
+ * Gets a reference to the underlying uniform random number generator
+ * object.
+ */
+ engine_value_type&
+ engine()
+ { return _M_engine; }
+
+ /**
+ * Gets a const reference to the underlying uniform random number
+ * generator object.
+ */
+ const engine_value_type&
+ engine() const
+ { return _M_engine; }
+
+ /**
+ * Gets a reference to the underlying random distribution.
+ */
+ distribution_type&
+ distribution()
+ { return _M_dist; }
+
+ /**
+ * Gets a const reference to the underlying random distribution.
+ */
+ const distribution_type&
+ distribution() const
+ { return _M_dist; }
+
+ /**
+ * Gets the closed lower bound of the distribution interval.
+ */
+ result_type
+ min() const
+ { return this->distribution().min(); }
+
+ /**
+ * Gets the closed upper bound of the distribution interval.
+ */
+ result_type
+ max() const
+ { return this->distribution().max(); }
+
+ private:
+ engine_value_type _M_engine;
+ distribution_type _M_dist;
+ };
+
+
+ /**
+ * @addtogroup tr1_random_generators Random Number Generators
+ * @ingroup tr1_random
+ *
+ * These classes define objects which provide random or pseudorandom
+ * numbers, either from a discrete or a continuous interval. The
+ * random number generator supplied as a part of this library are
+ * all uniform random number generators which provide a sequence of
+ * random number uniformly distributed over their range.
+ *
+ * A number generator is a function object with an operator() that
+ * takes zero arguments and returns a number.
+ *
+ * A compliant random number generator must satisy the following
+ * requirements. <table border=1 cellpadding=10 cellspacing=0>
+ * <caption align=top>Random Number Generator Requirements</caption>
+ * <tr><td>To be documented.</td></tr> </table>
+ *
+ * @{
+ */
+
+ /**
+ * @brief A model of a linear congruential random number generator.
+ *
+ * A random number generator that produces pseudorandom numbers using the
+ * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$.
+ *
+ * The template parameter @p _UIntType must be an unsigned integral type
+ * large enough to store values up to (__m-1). If the template parameter
+ * @p __m is 0, the modulus @p __m used is
+ * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
+ * parameters @p __a and @p __c must be less than @p __m.
+ *
+ * The size of the state is @f$ 1 @f$.
+ */
+ template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+ class linear_congruential
+ {
+ __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
+ // __glibcpp_class_requires(__a < __m && __c < __m)
+
+ public:
+ /** The type of the generated random value. */
+ typedef _UIntType result_type;
+
+ /** The multiplier. */
+ static const _UIntType multiplier = __a;
+ /** An increment. */
+ static const _UIntType increment = __c;
+ /** The modulus. */
+ static const _UIntType modulus = __m;
+
+ /**
+ * Constructs a %linear_congruential random number generator engine with
+ * seed @p __s. The default seed value is 1.
+ *
+ * @param __s The initial seed value.
+ */
+ explicit
+ linear_congruential(unsigned long __x0 = 1)
+ { this->seed(__x0); }
+
+ /**
+ * Constructs a %linear_congruential random number generator engine
+ * seeded from the generator function @p __g.
+ *
+ * @param __g The seed generator function.
+ */
+ template<class _Gen>
+ linear_congruential(_Gen& __g)
+ { this->seed(__g); }
+
+ /**
+ * Reseeds the %linear_congruential random number generator engine
+ * sequence to the seed @g __s.
+ *
+ * @param __s The new seed.
+ */
+ void
+ seed(unsigned long __s = 1);
+
+ /**
+ * Reseeds the %linear_congruential random number generator engine
+ * sequence using values from the generator function @p __g.
+ *
+ * @param __g the seed generator function.
+ */
+ template<class _Gen>
+ void
+ seed(_Gen& __g)
+ { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+ /**
+ * Gets the smallest possible value in the output range.
+ *
+ * The minumum depends on the @p __c parameter: if it is zero, the
+ * minimum generated must be > 0, otherwise 0 is allowed.
+ */
+ result_type
+ min() const
+ { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
+
+ /**
+ * Gets the largest possible value in the output range.
+ */
+ result_type
+ max() const
+ { return __m - 1; }
+
+ /**
+ * Gets the next random number in the sequence.
+ */
+ result_type
+ operator()();
+
+ /**
+ * Compares two linear congruential random number generator
+ * objects of the same type for equality.
+ *
+ * @param __lhs A linear congruential random number generator object.
+ * @param __rhs Another linear congruential random number generator obj.
+ *
+ * @returns true if the two objects are equal, false otherwise.
+ */
+ friend bool
+ operator==(const linear_congruential& __lhs,
+ const linear_congruential& __rhs)
+ { return __lhs._M_x == __rhs._M_x; }
+
+ /**
+ * Compares two linear congruential random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A linear congruential random number generator object.
+ * @param __rhs Another linear congruential random number generator obj.
+ *
+ * @returns true if the two objects are not equal, false otherwise.
+ */
+ friend bool
+ operator!=(const linear_congruential& __lhs,
+ const linear_congruential& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
+ * Writes the textual representation of the state x(i) of x to @p __os.
+ *
+ * @param __os The output stream.
+ * @param __lcr A % linear_congruential random number generator.
+ * @returns __os.
+ */
+ template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+ _UIntType1 __m1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const linear_congruential<_UIntType1, __a1, __c1,
+ __m1>& __lcr);
+
+ /**
+ * Sets the state of the engine by reading its textual
+ * representation from @p __is.
+ *
+ * The textual representation must have been previously written using an
+ * output stream whose imbued locale and whose type's template
+ * specialization arguments _CharT and _Traits were the same as those of
+ * @p __is.
+ *
+ * @param __is The input stream.
+ * @param __lcr A % linear_congruential random number generator.
+ * @returns __is.
+ */
+ template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+ _UIntType1 __m1,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr);
+
+ private:
+ template<class _Gen>
+ void
+ seed(_Gen& __g, true_type)
+ { return seed(static_cast<unsigned long>(__g)); }
+
+ template<class _Gen>
+ void
+ seed(_Gen& __g, false_type);
+
+ _UIntType _M_x;
+ };
+
+ /**
+ * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
+ */
+ typedef linear_congruential<unsigned long, 16807, 0, 2147483647> minstd_rand0;
+
+ /**
+ * An alternative LCR (Lehmer Generator function) .
+ */
+ typedef linear_congruential<unsigned long, 48271, 0, 2147483647> minstd_rand;
+
+
+ /**
+ * A generalized feedback shift register discrete random number generator.
+ *
+ * This algorithm avoind multiplication and division and is designed to be
+ * friendly to a pipelined architecture. If the parameters are chosen
+ * correctly, this generator will produce numbers with a very long period and
+ * fairly good apparent entropy, although still not cryptographically strong.
+ *
+ * The best way to use this generator is with the predefined mt19937 class.
+ *
+ * This algorithm was originally invented by Makoto Matsumoto and
+ * Takuji Nishimura.
+ *
+ * @var word_size The number of bits in each element of the state vector.
+ * @var state_size The degree of recursion.
+ * @var shift_size The period parameter.
+ * @var mask_bits The separation point bit index.
+ * @var parameter_a The last row of the twist matrix.
+ * @var output_u The first right-shift tempering matrix parameter.
+ * @var output_s The first left-shift tempering matrix parameter.
+ * @var output_b The first left-shift tempering matrix mask.
+ * @var output_t The second left-shift tempering matrix parameter.
+ * @var output_c The second left-shift tempering matrix mask.
+ * @var output_l The second right-shift tempering matrix parameter.
+ */
+ template<class _UIntType, int __w, int __n, int __m, int __r,
+ _UIntType __a, int __u, int __s, _UIntType __b, int __t,
+ _UIntType __c, int __l>
+ class mersenne_twister
+ {
+ __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
+
+ public:
+ // types
+ typedef _UIntType result_type;
+
+ // parameter values
+ static const int word_size = __w;
+ static const int state_size = __n;
+ static const int shift_size = __m;
+ static const int mask_bits = __r;
+ static const _UIntType parameter_a = __a;
+ static const int output_u = __u;
+ static const int output_s = __s;
+ static const _UIntType output_b = __b;
+ static const int output_t = __t;
+ static const _UIntType output_c = __c;
+ static const int output_l = __l;
+
+ // constructors and member function
+ mersenne_twister()
+ { seed(); }
+
+ explicit
+ mersenne_twister(unsigned long __value)
+ { seed(__value); }
+
+ template<class _Gen>
+ mersenne_twister(_Gen& __g)
+ { seed(__g); }
+
+ void
+ seed()
+ { seed(5489UL); }
+
+ void
+ seed(unsigned long __value);
+
+ template<class _Gen>
+ void
+ seed(_Gen& __g)
+ { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+ result_type
+ min() const
+ { return 0; };
+
+ result_type
+ max() const
+ { return __detail::_Shift<_UIntType, __w>::__value - 1; }
+
+ result_type
+ operator()();
+
+ /**
+ * Compares two % mersenne_twister random number generator objects of
+ * the same type for equality.
+ *
+ * @param __lhs A % mersenne_twister random number generator object.
+ * @param __rhs Another % mersenne_twister random number generator
+ * object.
+ *
+ * @returns true if the two objects are equal, false otherwise.
+ */
+ friend bool
+ operator==(const mersenne_twister& __lhs,
+ const mersenne_twister& __rhs)
+ { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); }
+
+ /**
+ * Compares two % mersenne_twister random number generator objects of
+ * the same type for inequality.
+ *
+ * @param __lhs A % mersenne_twister random number generator object.
+ * @param __rhs Another % mersenne_twister random number generator
+ * object.
+ *
+ * @returns true if the two objects are not equal, false otherwise.
+ */
+ friend bool
+ operator!=(const mersenne_twister& __lhs,
+ const mersenne_twister& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
+ * Inserts the current state of a % mersenne_twister random number
+ * generator engine @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A % mersenne_twister random number generator engine.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
+ _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
+ _UIntType1 __c1, int __l1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
+ __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
+
+ /**
+ * Extracts the current state of a % mersenne_twister random number
+ * generator engine @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A % mersenne_twister random number generator engine.
+ *
+ * @returns The input stream with the state of @p __x extracted or in
+ * an error state.
+ */
+ template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
+ _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
+ _UIntType1 __c1, int __l1,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
+ __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
+
+ private:
+ template<class _Gen>
+ void
+ seed(_Gen& __g, true_type)
+ { return seed(static_cast<unsigned long>(__g)); }
+
+ template<class _Gen>
+ void
+ seed(_Gen& __g, false_type);
+
+ _UIntType _M_x[state_size];
+ int _M_p;
+ };
+
+ /**
+ * The classic Mersenne Twister.
+ *
+ * Reference:
+ * M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
+ * Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions
+ * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
+ */
+ typedef mersenne_twister<
+ unsigned long, 32, 624, 397, 31,
+ 0x9908b0dful, 11, 7,
+ 0x9d2c5680ul, 15,
+ 0xefc60000ul, 18
+ > mt19937;
+
+
+ /**
+ * @brief The Marsaglia-Zaman generator.
+ *
+ * This is a model of a Generalized Fibonacci discrete random number
+ * generator, sometimes referred to as the SWC generator.
+ *
+ * A discrete random number generator that produces pseudorandom
+ * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} -
+ * carry_{i-1}) \bmod m @f$.
+ *
+ * The size of the state is @f$ r @f$
+ * and the maximum period of the generator is @f$ m^r - m^s -1 @f$.
+ *
+ * N1688[4.13] says "the template parameter _IntType shall denote an integral
+ * type large enough to store values up to m."
+ *
+ * @if maint
+ * @var _M_x The state of the generator. This is a ring buffer.
+ * @var _M_carry The carry.
+ * @var _M_p Current index of x(i - r).
+ * @endif
+ */
+ template<typename _IntType, _IntType __m, int __s, int __r>
+ class subtract_with_carry
+ {
+ __glibcxx_class_requires(_IntType, _IntegerConcept)
+
+ public:
+ /** The type of the generated random value. */
+ typedef _IntType result_type;
+
+ // parameter values
+ static const _IntType modulus = __m;
+ static const int long_lag = __r;
+ static const int short_lag = __s;
+
+ /**
+ * Constructs a default-initialized % subtract_with_carry random number
+ * generator.
+ */
+ subtract_with_carry()
+ { this->seed(); }
+
+ /**
+ * Constructs an explicitly seeded % subtract_with_carry random number
+ * generator.
+ */
+ explicit
+ subtract_with_carry(unsigned long __value)
+ { this->seed(__value); }
+
+ /**
+ * Constructs a %subtract_with_carry random number generator engine
+ * seeded from the generator function @p __g.
+ *
+ * @param __g The seed generator function.
+ */
+ template<class _Gen>
+ subtract_with_carry(_Gen& __g)
+ { this->seed(__g); }
+
+ /**
+ * Seeds the initial state @f$ x_0 @f$ of the random number generator.
+ *
+ * N1688[4.19] modifies this as follows. If @p __value == 0,
+ * sets value to 19780503. In any case, with a linear
+ * congruential generator lcg(i) having parameters @f$ m_{lcg} =
+ * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
+ * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
+ * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$
+ * set carry to 1, otherwise sets carry to 0.
+ */
+ void
+ seed(unsigned long __value = 19780503);
+
+ /**
+ * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry
+ * random number generator.
+ */
+ template<class _Gen>
+ void
+ seed(_Gen& __g)
+ { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+ /**
+ * Gets the inclusive minimum value of the range of random integers
+ * returned by this generator.
+ */
+ result_type
+ min() const
+ { return 0; }
+
+ /**
+ * Gets the inclusive maximum value of the range of random integers
+ * returned by this generator.
+ */
+ result_type
+ max() const
+ { return this->modulus - 1; }
+
+ /**
+ * Gets the next random number in the sequence.
+ */
+ result_type
+ operator()();
+
+ /**
+ * Compares two % subtract_with_carry random number generator objects of
+ * the same type for equality.
+ *
+ * @param __lhs A % subtract_with_carry random number generator object.
+ * @param __rhs Another % subtract_with_carry random number generator
+ * object.
+ *
+ * @returns true if the two objects are equal, false otherwise.
+ */
+ friend bool
+ operator==(const subtract_with_carry& __lhs,
+ const subtract_with_carry& __rhs)
+ { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); }
+
+ /**
+ * Compares two % subtract_with_carry random number generator objects of
+ * the same type for inequality.
+ *
+ * @param __lhs A % subtract_with_carry random number generator object.
+ * @param __rhs Another % subtract_with_carry random number generator
+ * object.
+ *
+ * @returns true if the two objects are not equal, false otherwise.
+ */
+ friend bool
+ operator!=(const subtract_with_carry& __lhs,
+ const subtract_with_carry& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
+ * Inserts the current state of a % subtract_with_carry random number
+ * generator engine @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A % subtract_with_carry random number generator engine.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const subtract_with_carry<_IntType1, __m1, __s1,
+ __r1>& __x);
+
+ /**
+ * Extracts the current state of a % subtract_with_carry random number
+ * generator engine @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A % subtract_with_carry random number generator engine.
+ *
+ * @returns The input stream with the state of @p __x extracted or in
+ * an error state.
+ */
+ template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x);
+
+ private:
+ template<class _Gen>
+ void
+ seed(_Gen& __g, true_type)
+ { return seed(static_cast<unsigned long>(__g)); }
+
+ template<class _Gen>
+ void
+ seed(_Gen& __g, false_type);
+
+ typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType;
+
+ _UIntType _M_x[long_lag];
+ _UIntType _M_carry;
+ int _M_p;
+ };
+
+
+ /**
+ * @brief The Marsaglia-Zaman generator (floats version).
+ *
+ * @if maint
+ * @var _M_x The state of the generator. This is a ring buffer.
+ * @var _M_carry The carry.
+ * @var _M_p Current index of x(i - r).
+ * @var _M_npows Precomputed negative powers of 2.
+ * @endif
+ */
+ template<typename _RealType, int __w, int __s, int __r>
+ class subtract_with_carry_01
+ {
+ public:
+ /** The type of the generated random value. */
+ typedef _RealType result_type;
+
+ // parameter values
+ static const int word_size = __w;
+ static const int long_lag = __r;
+ static const int short_lag = __s;
+
+ /**
+ * Constructs a default-initialized % subtract_with_carry_01 random
+ * number generator.
+ */
+ subtract_with_carry_01()
+ {
+ this->seed();
+ _M_initialize_npows();
+ }
+
+ /**
+ * Constructs an explicitly seeded % subtract_with_carry_01 random number
+ * generator.
+ */
+ explicit
+ subtract_with_carry_01(unsigned long __value)
+ {
+ this->seed(__value);
+ _M_initialize_npows();
+ }
+
+ /**
+ * Constructs a % subtract_with_carry_01 random number generator engine
+ * seeded from the generator function @p __g.
+ *
+ * @param __g The seed generator function.
+ */
+ template<class _Gen>
+ subtract_with_carry_01(_Gen& __g)
+ {
+ this->seed(__g);
+ _M_initialize_npows();
+ }
+
+ /**
+ * Seeds the initial state @f$ x_0 @f$ of the random number generator.
+ */
+ void
+ seed(unsigned long __value = 19780503);
+
+ /**
+ * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry_01
+ * random number generator.
+ */
+ template<class _Gen>
+ void
+ seed(_Gen& __g)
+ { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+ /**
+ * Gets the minimum value of the range of random floats
+ * returned by this generator.
+ */
+ result_type
+ min() const
+ { return 0.0; }
+
+ /**
+ * Gets the maximum value of the range of random floats
+ * returned by this generator.
+ */
+ result_type
+ max() const
+ { return 1.0; }
+
+ /**
+ * Gets the next random number in the sequence.
+ */
+ result_type
+ operator()();
+
+ /**
+ * Compares two % subtract_with_carry_01 random number generator objects
+ * of the same type for equality.
+ *
+ * @param __lhs A % subtract_with_carry_01 random number
+ * generator object.
+ * @param __rhs Another % subtract_with_carry_01 random number generator
+ * object.
+ *
+ * @returns true if the two objects are equal, false otherwise.
+ */
+ friend bool
+ operator==(const subtract_with_carry_01& __lhs,
+ const subtract_with_carry_01& __rhs)
+ {
+ for (int __i = 0; __i < long_lag; ++__i)
+ if (!std::equal(__lhs._M_x[__i], __lhs._M_x[__i] + __n,
+ __rhs._M_x[__i]))
+ return false;
+ return true;
+ }
+
+ /**
+ * Compares two % subtract_with_carry_01 random number generator objects
+ * of the same type for inequality.
+ *
+ * @param __lhs A % subtract_with_carry_01 random number
+ * generator object.
+ *
+ * @param __rhs Another % subtract_with_carry_01 random number generator
+ * object.
+ *
+ * @returns true if the two objects are not equal, false otherwise.
+ */
+ friend bool
+ operator!=(const subtract_with_carry_01& __lhs,
+ const subtract_with_carry_01& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
+ * Inserts the current state of a % subtract_with_carry_01 random number
+ * generator engine @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A % subtract_with_carry_01 random number generator engine.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, int __w1, int __s1, int __r1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const subtract_with_carry_01<_RealType1, __w1, __s1,
+ __r1>& __x);
+
+ /**
+ * Extracts the current state of a % subtract_with_carry_01 random number
+ * generator engine @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A % subtract_with_carry_01 random number generator engine.
+ *
+ * @returns The input stream with the state of @p __x extracted or in
+ * an error state.
+ */
+ template<typename _RealType1, int __w1, int __s1, int __r1,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x);
+
+ private:
+ template<class _Gen>
+ void
+ seed(_Gen& __g, true_type)
+ { return seed(static_cast<unsigned long>(__g)); }
+
+ template<class _Gen>
+ void
+ seed(_Gen& __g, false_type);
+
+ void
+ _M_initialize_npows();
+
+ static const int __n = (__w + 31) / 32;
+
+ typedef __detail::_UInt32Type _UInt32Type;
+ _UInt32Type _M_x[long_lag][__n];
+ _RealType _M_npows[__n];
+ _UInt32Type _M_carry;
+ int _M_p;
+ };
+
+ typedef subtract_with_carry_01<float, 24, 10, 24> ranlux_base_01;
+
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 508. Bad parameters for ranlux64_base_01.
+ typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;
+
+
+ /**
+ * Produces random numbers from some base engine by discarding blocks of
+ * data.
+ *
+ * 0 <= @p __r <= @p __p
+ */
+ template<class _UniformRandomNumberGenerator, int __p, int __r>
+ class discard_block
+ {
+ // __glibcxx_class_requires(typename base_type::result_type,
+ // ArithmeticTypeConcept)
+
+ public:
+ /** The type of the underlying generator engine. */
+ typedef _UniformRandomNumberGenerator base_type;
+ /** The type of the generated random value. */
+ typedef typename base_type::result_type result_type;
+
+ // parameter values
+ static const int block_size = __p;
+ static const int used_block = __r;
+
+ /**
+ * Constructs a default %discard_block engine.
+ *
+ * The underlying engine is default constructed as well.
+ */
+ discard_block()
+ : _M_n(0) { }
+
+ /**
+ * Copy constructs a %discard_block engine.
+ *
+ * Copies an existing base class random number geenerator.
+ * @param rng An existing (base class) engine object.
+ */
+ explicit
+ discard_block(const base_type& __rng)
+ : _M_b(__rng), _M_n(0) { }
+
+ /**
+ * Seed constructs a %discard_block engine.
+ *
+ * Constructs the underlying generator engine seeded with @p __s.
+ * @param __s A seed value for the base class engine.
+ */
+ explicit
+ discard_block(unsigned long __s)
+ : _M_b(__s), _M_n(0) { }
+
+ /**
+ * Generator construct a %discard_block engine.
+ *
+ * @param __g A seed generator function.
+ */
+ template<class _Gen>
+ discard_block(_Gen& __g)
+ : _M_b(__g), _M_n(0) { }
+
+ /**
+ * Reseeds the %discard_block object with the default seed for the
+ * underlying base class generator engine.
+ */
+ void seed()
+ {
+ _M_b.seed();
+ _M_n = 0;
+ }
+
+ /**
+ * Reseeds the %discard_block object with the given seed generator
+ * function.
+ * @param __g A seed generator function.
+ */
+ template<class _Gen>
+ void seed(_Gen& __g)
+ {
+ _M_b.seed(__g);
+ _M_n = 0;
+ }
+
+ /**
+ * Gets a const reference to the underlying generator engine object.
+ */
+ const base_type&
+ base() const
+ { return _M_b; }
+
+ /**
+ * Gets the minimum value in the generated random number range.
+ */
+ result_type
+ min() const
+ { return _M_b.min(); }
+
+ /**
+ * Gets the maximum value in the generated random number range.
+ */
+ result_type
+ max() const
+ { return _M_b.max(); }
+
+ /**
+ * Gets the next value in the generated random number sequence.
+ */
+ result_type
+ operator()();
+
+ /**
+ * Compares two %discard_block random number generator objects of
+ * the same type for equality.
+ *
+ * @param __lhs A %discard_block random number generator object.
+ * @param __rhs Another %discard_block random number generator
+ * object.
+ *
+ * @returns true if the two objects are equal, false otherwise.
+ */
+ friend bool
+ operator==(const discard_block& __lhs, const discard_block& __rhs)
+ { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
+
+ /**
+ * Compares two %discard_block random number generator objects of
+ * the same type for inequality.
+ *
+ * @param __lhs A %discard_block random number generator object.
+ * @param __rhs Another %discard_block random number generator
+ * object.
+ *
+ * @returns true if the two objects are not equal, false otherwise.
+ */
+ friend bool
+ operator!=(const discard_block& __lhs, const discard_block& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
+ * Inserts the current state of a %discard_block random number
+ * generator engine @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %discard_block random number generator engine.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const discard_block<_UniformRandomNumberGenerator1,
+ __p1, __r1>& __x);
+
+ /**
+ * Extracts the current state of a % subtract_with_carry random number
+ * generator engine @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %discard_block random number generator engine.
+ *
+ * @returns The input stream with the state of @p __x extracted or in
+ * an error state.
+ */
+ template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ discard_block<_UniformRandomNumberGenerator1,
+ __p1, __r1>& __x);
+
+ private:
+ base_type _M_b;
+ int _M_n;
+ };
+
+
+ /**
+ * James's luxury-level-3 integer adaptation of Luescher's generator.
+ */
+ typedef discard_block<
+ subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
+ 223,
+ 24
+ > ranlux3;
+
+ /**
+ * James's luxury-level-4 integer adaptation of Luescher's generator.
+ */
+ typedef discard_block<
+ subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
+ 389,
+ 24
+ > ranlux4;
+
+ typedef discard_block<
+ subtract_with_carry_01<float, 24, 10, 24>,
+ 223,
+ 24
+ > ranlux3_01;
+
+ typedef discard_block<
+ subtract_with_carry_01<float, 24, 10, 24>,
+ 389,
+ 24
+ > ranlux4_01;
+
+
+ /**
+ * A random number generator adaptor class that combines two random number
+ * generator engines into a single output sequence.
+ */
+ template<class _UniformRandomNumberGenerator1, int __s1,
+ class _UniformRandomNumberGenerator2, int __s2>
+ class xor_combine
+ {
+ // __glibcxx_class_requires(typename _UniformRandomNumberGenerator1::
+ // result_type, ArithmeticTypeConcept)
+ // __glibcxx_class_requires(typename _UniformRandomNumberGenerator2::
+ // result_type, ArithmeticTypeConcept)
+
+ public:
+ /** The type of the the first underlying generator engine. */
+ typedef _UniformRandomNumberGenerator1 base1_type;
+ /** The type of the the second underlying generator engine. */
+ typedef _UniformRandomNumberGenerator2 base2_type;
+
+ private:
+ typedef typename base1_type::result_type _Result_type1;
+ typedef typename base2_type::result_type _Result_type2;
+
+ public:
+ /** The type of the generated random value. */
+ typedef typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1)
+ > sizeof(_Result_type2)),
+ _Result_type1, _Result_type2>::__type result_type;
+
+ // parameter values
+ static const int shift1 = __s1;
+ static const int shift2 = __s2;
+
+ // constructors and member function
+ xor_combine()
+ : _M_b1(), _M_b2()
+ { _M_initialize_max(); }
+
+ xor_combine(const base1_type& __rng1, const base2_type& __rng2)
+ : _M_b1(__rng1), _M_b2(__rng2)
+ { _M_initialize_max(); }
+
+ xor_combine(unsigned long __s)
+ : _M_b1(__s), _M_b2(__s + 1)
+ { _M_initialize_max(); }
+
+ template<class _Gen>
+ xor_combine(_Gen& __g)
+ : _M_b1(__g), _M_b2(__g)
+ { _M_initialize_max(); }
+
+ void
+ seed()
+ {
+ _M_b1.seed();
+ _M_b2.seed();
+ }
+
+ template<class _Gen>
+ void
+ seed(_Gen& __g)
+ {
+ _M_b1.seed(__g);
+ _M_b2.seed(__g);
+ }
+
+ const base1_type&
+ base1() const
+ { return _M_b1; }
+
+ const base2_type&
+ base2() const
+ { return _M_b2; }
+
+ result_type
+ min() const
+ { return 0; }
+
+ result_type
+ max() const
+ { return _M_max; }
+
+ /**
+ * Gets the next random number in the sequence.
+ */
+ // NB: Not exactly the TR1 formula, per N2079 instead.
+ result_type
+ operator()()
+ {
+ return ((result_type(_M_b1() - _M_b1.min()) << shift1)
+ ^ (result_type(_M_b2() - _M_b2.min()) << shift2));
+ }
+
+ /**
+ * Compares two %xor_combine random number generator objects of
+ * the same type for equality.
+ *
+ * @param __lhs A %xor_combine random number generator object.
+ * @param __rhs Another %xor_combine random number generator
+ * object.
+ *
+ * @returns true if the two objects are equal, false otherwise.
+ */
+ friend bool
+ operator==(const xor_combine& __lhs, const xor_combine& __rhs)
+ {
+ return (__lhs.base1() == __rhs.base1())
+ && (__lhs.base2() == __rhs.base2());
+ }
+
+ /**
+ * Compares two %xor_combine random number generator objects of
+ * the same type for inequality.
+ *
+ * @param __lhs A %xor_combine random number generator object.
+ * @param __rhs Another %xor_combine random number generator
+ * object.
+ *
+ * @returns true if the two objects are not equal, false otherwise.
+ */
+ friend bool
+ operator!=(const xor_combine& __lhs, const xor_combine& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
+ * Inserts the current state of a %xor_combine random number
+ * generator engine @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %xor_combine random number generator engine.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<class _UniformRandomNumberGenerator11, int __s11,
+ class _UniformRandomNumberGenerator21, int __s21,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const xor_combine<_UniformRandomNumberGenerator11, __s11,
+ _UniformRandomNumberGenerator21, __s21>& __x);
+
+ /**
+ * Extracts the current state of a %xor_combine random number
+ * generator engine @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %xor_combine random number generator engine.
+ *
+ * @returns The input stream with the state of @p __x extracted or in
+ * an error state.
+ */
+ template<class _UniformRandomNumberGenerator11, int __s11,
+ class _UniformRandomNumberGenerator21, int __s21,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ xor_combine<_UniformRandomNumberGenerator11, __s11,
+ _UniformRandomNumberGenerator21, __s21>& __x);
+
+ private:
+ void
+ _M_initialize_max();
+
+ result_type
+ _M_initialize_max_aux(result_type, result_type, int);
+
+ base1_type _M_b1;
+ base2_type _M_b2;
+ result_type _M_max;
+ };
+
+
+ /**
+ * A standard interface to a platform-specific non-deterministic
+ * random number generator (if any are available).
+ */
+ class random_device
+ {
+ public:
+ // types
+ typedef unsigned int result_type;
+
+ // constructors, destructors and member functions
+
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+
+ explicit
+ random_device(const std::string& __token = "/dev/urandom")
+ {
+ if ((__token != "/dev/urandom" && __token != "/dev/random")
+ || !(_M_file = std::fopen(__token.c_str(), "rb")))
+ std::__throw_runtime_error(__N("random_device::"
+ "random_device(const std::string&)"));
+ }
+
+ ~random_device()
+ { std::fclose(_M_file); }
+
+#else
+
+ explicit
+ random_device(const std::string& __token = "mt19937")
+ : _M_mt(_M_strtoul(__token)) { }
+
+ private:
+ static unsigned long
+ _M_strtoul(const std::string& __str)
+ {
+ unsigned long __ret = 5489UL;
+ if (__str != "mt19937")
+ {
+ const char* __nptr = __str.c_str();
+ char* __endptr;
+ __ret = std::strtoul(__nptr, &__endptr, 0);
+ if (*__nptr == '\0' || *__endptr != '\0')
+ std::__throw_runtime_error(__N("random_device::_M_strtoul"
+ "(const std::string&)"));
+ }
+ return __ret;
+ }
+
+ public:
+
+#endif
+
+ result_type
+ min() const
+ { return std::numeric_limits<result_type>::min(); }
+
+ result_type
+ max() const
+ { return std::numeric_limits<result_type>::max(); }
+
+ double
+ entropy() const
+ { return 0.0; }
+
+ result_type
+ operator()()
+ {
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+ result_type __ret;
+ std::fread(reinterpret_cast<void*>(&__ret), sizeof(result_type),
+ 1, _M_file);
+ return __ret;
+#else
+ return _M_mt();
+#endif
+ }
+
+ private:
+ random_device(const random_device&);
+ void operator=(const random_device&);
+
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+ FILE* _M_file;
+#else
+ mt19937 _M_mt;
+#endif
+ };
+
+ /* @} */ // group tr1_random_generators
+
+ /**
+ * @addtogroup tr1_random_distributions Random Number Distributions
+ * @ingroup tr1_random
+ * @{
+ */
+
+ /**
+ * @addtogroup tr1_random_distributions_discrete Discrete Distributions
+ * @ingroup tr1_random_distributions
+ * @{
+ */
+
+ /**
+ * @brief Uniform discrete distribution for random numbers.
+ * A discrete random distribution on the range @f$[min, max]@f$ with equal
+ * probability throughout the range.
+ */
+ template<typename _IntType = int>
+ class uniform_int
+ {
+ __glibcxx_class_requires(_IntType, _IntegerConcept)
+
+ public:
+ /** The type of the parameters of the distribution. */
+ typedef _IntType input_type;
+ /** The type of the range of the distribution. */
+ typedef _IntType result_type;
+
+ public:
+ /**
+ * Constructs a uniform distribution object.
+ */
+ explicit
+ uniform_int(_IntType __min = 0, _IntType __max = 9)
+ : _M_min(__min), _M_max(__max)
+ {
+ _GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
+ }
+
+ /**
+ * Gets the inclusive lower bound of the distribution range.
+ */
+ result_type
+ min() const
+ { return _M_min; }
+
+ /**
+ * Gets the inclusive upper bound of the distribution range.
+ */
+ result_type
+ max() const
+ { return _M_max; }
+
+ /**
+ * Resets the distribution state.
+ *
+ * Does nothing for the uniform integer distribution.
+ */
+ void
+ reset() { }
+
+ /**
+ * Gets a uniformly distributed random number in the range
+ * @f$(min, max)@f$.
+ */
+ template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ {
+ typedef typename _UniformRandomNumberGenerator::result_type
+ _UResult_type;
+ return _M_call(__urng, _M_min, _M_max,
+ typename is_integral<_UResult_type>::type());
+ }
+
+ /**
+ * Gets a uniform random number in the range @f$[0, n)@f$.
+ *
+ * This function is aimed at use with std::random_shuffle.
+ */
+ template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng, result_type __n)
+ {
+ typedef typename _UniformRandomNumberGenerator::result_type
+ _UResult_type;
+ return _M_call(__urng, 0, __n - 1,
+ typename is_integral<_UResult_type>::type());
+ }
+
+ /**
+ * Inserts a %uniform_int random number distribution @p __x into the
+ * output stream @p os.
+ *
+ * @param __os An output stream.
+ * @param __x A %uniform_int random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const uniform_int<_IntType1>& __x);
+
+ /**
+ * Extracts a %unform_int random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %uniform_int random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ uniform_int<_IntType1>& __x);
+
+ private:
+ template<typename _UniformRandomNumberGenerator>
+ result_type
+ _M_call(_UniformRandomNumberGenerator& __urng,
+ result_type __min, result_type __max, true_type)
+ { return result_type(__urng() % (__max - __min + 1)) + __min; }
+
+ template<typename _UniformRandomNumberGenerator>
+ result_type
+ _M_call(_UniformRandomNumberGenerator& __urng,
+ result_type __min, result_type __max, false_type)
+ {
+ return result_type((__urng() - __urng.min())
+ / (__urng.max() - __urng.min())
+ * (__max - __min + 1)) + __min;
+ }
+
+ _IntType _M_min;
+ _IntType _M_max;
+ };
+
+
+ /**
+ * @brief A Bernoulli random number distribution.
+ *
+ * Generates a sequence of true and false values with likelihood @f$ p @f$
+ * that true will come up and @f$ (1 - p) @f$ that false will appear.
+ */
+ class bernoulli_distribution
+ {
+ public:
+ typedef int input_type;
+ typedef bool result_type;
+
+ public:
+ /**
+ * Constructs a Bernoulli distribution with likelihood @p p.
+ *
+ * @param __p [IN] The likelihood of a true result being returned. Must
+ * be in the interval @f$ [0, 1] @f$.
+ */
+ explicit
+ bernoulli_distribution(double __p = 0.5)
+ : _M_p(__p)
+ {
+ _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
+ }
+
+ /**
+ * Gets the @p p parameter of the distribution.
+ */
+ double
+ p() const
+ { return _M_p; }
+
+ /**
+ * Resets the distribution state.
+ *
+ * Does nothing for a bernoulli distribution.
+ */
+ void
+ reset() { }
+
+ /**
+ * Gets the next value in the Bernoullian sequence.
+ */
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ {
+ if ((__urng() - __urng.min()) < _M_p * (__urng.max() - __urng.min()))
+ return true;
+ return false;
+ }
+
+ /**
+ * Inserts a %bernoulli_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %bernoulli_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const bernoulli_distribution& __x);
+
+ /**
+ * Extracts a %bernoulli_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %bernoulli_distribution random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ bernoulli_distribution& __x)
+ { return __is >> __x._M_p; }
+
+ private:
+ double _M_p;
+ };
+
+
+ /**
+ * @brief A discrete geometric random number distribution.
+ *
+ * The formula for the geometric probability mass function is
+ * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
+ * distribution.
+ */
+ template<typename _IntType = int, typename _RealType = double>
+ class geometric_distribution
+ {
+ public:
+ // types
+ typedef _RealType input_type;
+ typedef _IntType result_type;
+
+ // constructors and member function
+ explicit
+ geometric_distribution(const _RealType& __p = _RealType(0.5))
+ : _M_p(__p)
+ {
+ _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
+ _M_initialize();
+ }
+
+ /**
+ * Gets the distribution parameter @p p.
+ */
+ _RealType
+ p() const
+ { return _M_p; }
+
+ void
+ reset() { }
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng);
+
+ /**
+ * Inserts a %geometric_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %geometric_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _IntType1, typename _RealType1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const geometric_distribution<_IntType1, _RealType1>& __x);
+
+ /**
+ * Extracts a %geometric_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %geometric_distribution random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ geometric_distribution& __x)
+ {
+ __is >> __x._M_p;
+ __x._M_initialize();
+ return __is;
+ }
+
+ private:
+ void
+ _M_initialize()
+ { _M_log_p = std::log(_M_p); }
+
+ _RealType _M_p;
+ _RealType _M_log_p;
+ };
+
+
+ template<typename _RealType>
+ class normal_distribution;
+
+ /**
+ * @brief A discrete Poisson random number distribution.
+ *
+ * The formula for the poisson probability mass function is
+ * @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the
+ * parameter of the distribution.
+ */
+ template<typename _IntType = int, typename _RealType = double>
+ class poisson_distribution
+ {
+ public:
+ // types
+ typedef _RealType input_type;
+ typedef _IntType result_type;
+
+ // constructors and member function
+ explicit
+ poisson_distribution(const _RealType& __mean = _RealType(1))
+ : _M_mean(__mean), _M_nd()
+ {
+ _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
+ _M_initialize();
+ }
+
+ /**
+ * Gets the distribution parameter @p mean.
+ */
+ _RealType
+ mean() const
+ { return _M_mean; }
+
+ void
+ reset()
+ { _M_nd.reset(); }
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng);
+
+ /**
+ * Inserts a %poisson_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %poisson_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _IntType1, typename _RealType1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const poisson_distribution<_IntType1, _RealType1>& __x);
+
+ /**
+ * Extracts a %poisson_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %poisson_distribution random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _IntType1, typename _RealType1,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ poisson_distribution<_IntType1, _RealType1>& __x);
+
+ private:
+ void
+ _M_initialize();
+
+ // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+ normal_distribution<_RealType> _M_nd;
+
+ _RealType _M_mean;
+
+ // Hosts either log(mean) or the threshold of the simple method.
+ _RealType _M_lm_thr;
+#if _GLIBCXX_USE_C99_MATH_TR1
+ _RealType _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
+#endif
+ };
+
+
+ /**
+ * @brief A discrete binomial random number distribution.
+ *
+ * The formula for the binomial probability mass function is
+ * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
+ * and @f$ p @f$ are the parameters of the distribution.
+ */
+ template<typename _IntType = int, typename _RealType = double>
+ class binomial_distribution
+ {
+ public:
+ // types
+ typedef _RealType input_type;
+ typedef _IntType result_type;
+
+ // constructors and member function
+ explicit
+ binomial_distribution(_IntType __t = 1,
+ const _RealType& __p = _RealType(0.5))
+ : _M_t(__t), _M_p(__p), _M_nd()
+ {
+ _GLIBCXX_DEBUG_ASSERT((_M_t >= 0) && (_M_p >= 0.0) && (_M_p <= 1.0));
+ _M_initialize();
+ }
+
+ /**
+ * Gets the distribution @p t parameter.
+ */
+ _IntType
+ t() const
+ { return _M_t; }
+
+ /**
+ * Gets the distribution @p p parameter.
+ */
+ _RealType
+ p() const
+ { return _M_p; }
+
+ void
+ reset()
+ { _M_nd.reset(); }
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng);
+
+ /**
+ * Inserts a %binomial_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %binomial_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _IntType1, typename _RealType1,
+ typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const binomial_distribution<_IntType1, _RealType1>& __x);
+
+ /**
+ * Extracts a %binomial_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %binomial_distribution random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _IntType1, typename _RealType1,
+ typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ binomial_distribution<_IntType1, _RealType1>& __x);
+
+ private:
+ void
+ _M_initialize();
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
+
+ // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+ normal_distribution<_RealType> _M_nd;
+
+ _RealType _M_q;
+#if _GLIBCXX_USE_C99_MATH_TR1
+ _RealType _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
+ _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
+#endif
+ _RealType _M_p;
+ _IntType _M_t;
+
+ bool _M_easy;
+ };
+
+ /* @} */ // group tr1_random_distributions_discrete
+
+ /**
+ * @addtogroup tr1_random_distributions_continuous Continuous Distributions
+ * @ingroup tr1_random_distributions
+ * @{
+ */
+
+ /**
+ * @brief Uniform continuous distribution for random numbers.
+ *
+ * A continuous random distribution on the range [min, max) with equal
+ * probability throughout the range. The URNG should be real-valued and
+ * deliver number in the range [0, 1).
+ */
+ template<typename _RealType = double>
+ class uniform_real
+ {
+ public:
+ // types
+ typedef _RealType input_type;
+ typedef _RealType result_type;
+
+ public:
+ /**
+ * Constructs a uniform_real object.
+ *
+ * @param __min [IN] The lower bound of the distribution.
+ * @param __max [IN] The upper bound of the distribution.
+ */
+ explicit
+ uniform_real(_RealType __min = _RealType(0),
+ _RealType __max = _RealType(1))
+ : _M_min(__min), _M_max(__max)
+ {
+ _GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
+ }
+
+ result_type
+ min() const
+ { return _M_min; }
+
+ result_type
+ max() const
+ { return _M_max; }
+
+ void
+ reset() { }
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return (__urng() * (_M_max - _M_min)) + _M_min; }
+
+ /**
+ * Inserts a %uniform_real random number distribution @p __x into the
+ * output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %uniform_real random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const uniform_real<_RealType1>& __x);
+
+ /**
+ * Extracts a %unform_real random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %uniform_real random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ uniform_real<_RealType1>& __x);
+
+ private:
+ _RealType _M_min;
+ _RealType _M_max;
+ };
+
+
+ /**
+ * @brief An exponential continuous distribution for random numbers.
+ *
+ * The formula for the exponential probability mass function is
+ * @f$ p(x) = \lambda e^{-\lambda x} @f$.
+ *
+ * <table border=1 cellpadding=10 cellspacing=0>
+ * <caption align=top>Distribution Statistics</caption>
+ * <tr><td>Mean</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
+ * <tr><td>Median</td><td>@f$ \frac{\ln 2}{\lambda} @f$</td></tr>
+ * <tr><td>Mode</td><td>@f$ zero @f$</td></tr>
+ * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
+ * <tr><td>Standard Deviation</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
+ * </table>
+ */
+ template<typename _RealType = double>
+ class exponential_distribution
+ {
+ public:
+ // types
+ typedef _RealType input_type;
+ typedef _RealType result_type;
+
+ public:
+ /**
+ * Constructs an exponential distribution with inverse scale parameter
+ * @f$ \lambda @f$.
+ */
+ explicit
+ exponential_distribution(const result_type& __lambda = result_type(1))
+ : _M_lambda(__lambda)
+ {
+ _GLIBCXX_DEBUG_ASSERT(_M_lambda > 0);
+ }
+
+ /**
+ * Gets the inverse scale parameter of the distribution.
+ */
+ _RealType
+ lambda() const
+ { return _M_lambda; }
+
+ /**
+ * Resets the distribution.
+ *
+ * Has no effect on exponential distributions.
+ */
+ void
+ reset() { }
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return -std::log(__urng()) / _M_lambda; }
+
+ /**
+ * Inserts a %exponential_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %exponential_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const exponential_distribution<_RealType1>& __x);
+
+ /**
+ * Extracts a %exponential_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %exponential_distribution random number
+ * generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ exponential_distribution& __x)
+ { return __is >> __x._M_lambda; }
+
+ private:
+ result_type _M_lambda;
+ };
+
+
+ /**
+ * @brief A normal continuous distribution for random numbers.
+ *
+ * The formula for the normal probability mass function is
+ * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}}
+ * e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$.
+ */
+ template<typename _RealType = double>
+ class normal_distribution
+ {
+ public:
+ // types
+ typedef _RealType input_type;
+ typedef _RealType result_type;
+
+ public:
+ /**
+ * Constructs a normal distribution with parameters @f$ mean @f$ and
+ * @f$ \sigma @f$.
+ */
+ explicit
+ normal_distribution(const result_type& __mean = result_type(0),
+ const result_type& __sigma = result_type(1))
+ : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false)
+ {
+ _GLIBCXX_DEBUG_ASSERT(_M_sigma > 0);
+ }
+
+ /**
+ * Gets the mean of the distribution.
+ */
+ _RealType
+ mean() const
+ { return _M_mean; }
+
+ /**
+ * Gets the @f$ \sigma @f$ of the distribution.
+ */
+ _RealType
+ sigma() const
+ { return _M_sigma; }
+
+ /**
+ * Resets the distribution.
+ */
+ void
+ reset()
+ { _M_saved_available = false; }
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng);
+
+ /**
+ * Inserts a %normal_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %normal_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const normal_distribution<_RealType1>& __x);
+
+ /**
+ * Extracts a %normal_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %normal_distribution random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ normal_distribution<_RealType1>& __x);
+
+ private:
+ result_type _M_mean;
+ result_type _M_sigma;
+ result_type _M_saved;
+ bool _M_saved_available;
+ };
+
+
+ /**
+ * @brief A gamma continuous distribution for random numbers.
+ *
+ * The formula for the gamma probability mass function is
+ * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$.
+ */
+ template<typename _RealType = double>
+ class gamma_distribution
+ {
+ public:
+ // types
+ typedef _RealType input_type;
+ typedef _RealType result_type;
+
+ public:
+ /**
+ * Constructs a gamma distribution with parameters @f$ \alpha @f$.
+ */
+ explicit
+ gamma_distribution(const result_type& __alpha_val = result_type(1))
+ : _M_alpha(__alpha_val)
+ {
+ _GLIBCXX_DEBUG_ASSERT(_M_alpha > 0);
+ _M_initialize();
+ }
+
+ /**
+ * Gets the @f$ \alpha @f$ of the distribution.
+ */
+ _RealType
+ alpha() const
+ { return _M_alpha; }
+
+ /**
+ * Resets the distribution.
+ */
+ void
+ reset() { }
+
+ template<class _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng);
+
+ /**
+ * Inserts a %gamma_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %gamma_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const gamma_distribution<_RealType1>& __x);
+
+ /**
+ * Extracts a %gamma_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %gamma_distribution random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ gamma_distribution& __x)
+ {
+ __is >> __x._M_alpha;
+ __x._M_initialize();
+ return __is;
+ }
+
+ private:
+ void
+ _M_initialize();
+
+ result_type _M_alpha;
+
+ // Hosts either lambda of GB or d of modified Vaduva's.
+ result_type _M_l_d;
+ };
+
+ /* @} */ // group tr1_random_distributions_continuous
+ /* @} */ // group tr1_random_distributions
+ /* @} */ // group tr1_random
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
+#include <tr1_impl/random.tcc>
// random number generation (out of line) -*- C++ -*-
-// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
-/** @file tr1/random.tcc
- * This is a TR1 C++ Library header.
+/** @file tr1_impl/random.tcc
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
*/
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
/*
* (Further) implementation-space details.
if (__value == 0)
__value = 19780503;
- std::_GLIBCXX_TR1::linear_congruential<unsigned long, 40014, 0, 2147483563>
+ std::_GLIBCXX_TR1 linear_congruential<unsigned long, 40014, 0, 2147483563>
__lcg(__value);
for (int __i = 0; __i < long_lag; ++__i)
{
for (int __j = 0; __j < __n; ++__j)
#if _GLIBCXX_USE_C99_MATH_TR1
- _M_npows[__j] = std::_GLIBCXX_TR1::ldexp(_RealType(1), -__w + __j * 32);
+ _M_npows[__j] = std::_GLIBCXX_TR1 ldexp(_RealType(1), -__w + __j * 32);
#else
_M_npows[__j] = std::pow(_RealType(2), -__w + __j * 32);
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 512. Seeding subtract_with_carry_01 from a single unsigned long.
- std::_GLIBCXX_TR1::linear_congruential<unsigned long, 40014, 0, 2147483563>
+ std::_GLIBCXX_TR1 linear_congruential<unsigned long, 40014, 0, 2147483563>
__lcg(__value);
this->seed(__lcg);
{
const _RealType __m = std::floor(_M_mean);
_M_lm_thr = std::log(_M_mean);
- _M_lfm = std::_GLIBCXX_TR1::lgamma(__m + 1);
+ _M_lfm = std::_GLIBCXX_TR1 lgamma(__m + 1);
_M_sm = std::sqrt(__m);
const _RealType __pi_4 = 0.7853981633974483096156608458198757L;
const _RealType __dx = std::sqrt(2 * __m * std::log(32 * __m
/ __pi_4));
- _M_d = std::_GLIBCXX_TR1::round(std::max(_RealType(6),
- std::min(__m, __dx)));
+ _M_d = std::_GLIBCXX_TR1 round(std::max(_RealType(6),
+ std::min(__m, __dx)));
const _RealType __cx = 2 * __m + _M_d;
_M_scx = std::sqrt(__cx / 2);
_M_1cx = 1 / __cx;
}
__reject = (__w - __e - __x * _M_lm_thr
- > _M_lfm - std::_GLIBCXX_TR1::lgamma(__x + __m + 1));
+ > _M_lfm - std::_GLIBCXX_TR1 lgamma(__x + __m + 1));
__reject |= __x + __m >= __thr;
const _RealType __d1x =
std::sqrt(__np * __1p * std::log(32 * __np
/ (81 * __pi_4 * __1p)));
- _M_d1 = std::_GLIBCXX_TR1::round(std::max(_RealType(1), __d1x));
+ _M_d1 = std::_GLIBCXX_TR1 round(std::max(_RealType(1), __d1x));
const _RealType __d2x =
std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
/ (__pi_4 * __pa)));
- _M_d2 = std::_GLIBCXX_TR1::round(std::max(_RealType(1), __d2x));
+ _M_d2 = std::_GLIBCXX_TR1 round(std::max(_RealType(1), __d2x));
// sqrt(pi / 2)
const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
const _RealType __s2s = _M_s2 * _M_s2;
_M_s = (_M_a123 + 2 * __s2s / _M_d2
* std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
- _M_lf = (std::_GLIBCXX_TR1::lgamma(__np + 1)
- + std::_GLIBCXX_TR1::lgamma(_M_t - __np + 1));
+ _M_lf = (std::_GLIBCXX_TR1 lgamma(__np + 1)
+ + std::_GLIBCXX_TR1 lgamma(_M_t - __np + 1));
_M_lp1p = std::log(__pa / __1p);
_M_q = -std::log(1 - (__p12 - __pa) / __1p);
if (!__reject)
{
const _RealType __lfx =
- std::_GLIBCXX_TR1::lgamma(__np + __x + 1)
- + std::_GLIBCXX_TR1::lgamma(_M_t - (__np + __x) + 1);
+ std::_GLIBCXX_TR1 lgamma(__np + __x + 1)
+ + std::_GLIBCXX_TR1 lgamma(_M_t - (__np + __x) + 1);
__reject = __v > _M_lf - __lfx + __x * _M_lp1p;
}
return __os;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_TR1
}
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/**
+ * @file tr1_impl/regex
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+/**
+ * @addtogroup tr1_regex Regular Expressions
+ * A facility for performing regular expression pattern matching.
+ * @{
+ */
+
+namespace regex_constants
+{
+ // [7.5.1] Bitmask Type syntax_option_type
+ enum __syntax_option
+ {
+ _S_icase,
+ _S_nosubs,
+ _S_optimize,
+ _S_collate,
+ _S_ECMAScript,
+ _S_basic,
+ _S_extended,
+ _S_awk,
+ _S_grep,
+ _S_egrep,
+ _S_syntax_last
+ };
+
+ /**
+ * @brief This is a bitmask type indicating how to interpret the regex.
+ *
+ * The @c syntax_option_type is implementation defined but it is valid to
+ * perform bitwise operations on these values and expect the right thing to
+ * happen.
+ *
+ * A valid value of type syntax_option_type shall have exactly one of the
+ * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
+ * set.
+ */
+ typedef unsigned int syntax_option_type;
+
+ /// Specifies that the matching of regular expressions against a character
+ /// sequence shall be performed without regard to case.
+ static const syntax_option_type icase = 1 << _S_icase;
+
+ /// Specifies that when a regular expression is matched against a character
+ /// container sequence, no sub-expression matches are to be stored in the
+ /// supplied match_results structure.
+ static const syntax_option_type nosubs = 1 << _S_nosubs;
+
+ /// Specifies that the regular expression engine should pay more attention to
+ /// the speed with which regular expressions are matched, and less to the
+ /// speed with which regular expression objects are constructed. Otherwise
+ /// it has no detectable effect on the program output.
+ static const syntax_option_type optimize = 1 << _S_optimize;
+
+ /// Specifies that character ranges of the form [a-b] should be locale
+ /// sensitive.
+ static const syntax_option_type collate = 1 << _S_collate;
+
+ /// Specifies that the grammar recognized by the regular expression engine is
+ /// that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
+ /// Language Specification, Standard Ecma-262, third edition, 1999], as
+ /// modified in tr1 section [7.13]. This grammar is similar to that defined
+ /// in the PERL scripting language but extended with elements found in the
+ /// POSIX regular expression grammar.
+ static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
+
+ /// Specifies that the grammar recognized by the regular expression engine is
+ /// that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
+ /// Portable Operating System Interface (POSIX), Base Definitions and
+ /// Headers, Section 9, Regular Expressions [IEEE, Information Technology --
+ /// Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+ static const syntax_option_type basic = 1 << _S_basic;
+
+ /// Specifies that the grammar recognized by the regular expression engine is
+ /// that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
+ /// Portable Operating System Interface (POSIX), Base Definitions and Headers,
+ /// Section 9, Regular Expressions.
+ static const syntax_option_type extended = 1 << _S_extended;
+
+ /// Specifies that the grammar recognized by the regular expression engine is
+ /// that used by POSIX utility awk in IEEE Std 1003.1-2001. This option is
+ /// identical to syntax_option_type extended, except that C-style escape
+ /// sequences are supported. These sequences are, explicitly, '\\', '\a',
+ /// '\b', '\f', '\n', '\r', '\t' , '\v', '\"', '\\', and '\ddd' (where ddd is
+ /// one, two, or three octal digits).
+ static const syntax_option_type awk = 1 << _S_awk;
+
+ /// Specifies that the grammar recognized by the regular expression engine is
+ /// that used by POSIX utility grep in IEEE Std 1003.1-2001. This option is
+ /// identical to syntax_option_type basic, except that newlines are treated
+ /// as whitespace.
+ static const syntax_option_type grep = 1 << _S_grep;
+
+ /// Specifies that the grammar recognized by the regular expression engine is
+ /// that used by POSIX utility grep when given the -E option in
+ /// IEEE Std 1003.1-2001. This option is identical to syntax_option_type
+ /// extended, except that newlines are treated as whitespace.
+ static const syntax_option_type egrep = 1 << _S_egrep;
+
+
+ // [7.5.2] Bitmask Type match_flag_type
+ enum __match_flag
+ {
+ _S_not_bol,
+ _S_not_eol,
+ _S_not_bow,
+ _S_not_eow,
+ _S_any,
+ _S_not_null,
+ _S_continuous,
+ _S_prev_avail,
+ _S_sed,
+ _S_no_copy,
+ _S_first_only,
+ _S_match_flag_last
+ };
+
+ /**
+ * @brief This is a bitmask type indicating regex matching rules.
+ *
+ * Matching a regular expression against a sequence of characters [first,
+ * last) proceeds according to the rules of the grammar specified for the
+ * regular expression object, modified according to the effects listed
+ * below for any bitmask elements set.
+ *
+ * The @c match_flag_type is implementation defined but it is valid to
+ * perform bitwise operations on these values and expect the right thing to
+ * happen.
+ */
+ typedef std::bitset<_S_match_flag_last> match_flag_type;
+
+ static const match_flag_type match_default = 0;
+
+ /// The first character in the sequence [first, last) is treated as though it
+ /// is not at the beginning of a line, so the character "^" in the regular
+ /// expression shall not match [first, first).
+ static const match_flag_type match_not_bol = 1 << _S_not_bol;
+
+ /// The last character in the sequence [first, last) is treated as though it
+ /// is not at the end of a line, so the character "$" in the regular
+ /// expression shall not match [last, last).
+ static const match_flag_type match_not_eol = 1 << _S_not_eol;
+
+ /// The expression "\b" is not matched against the sub-sequence
+ /// [first,first).
+ static const match_flag_type match_not_bow = 1 << _S_not_bow;
+
+ /// The expression "\b" should not be matched against the sub-sequence
+ /// [last,last).
+ static const match_flag_type match_not_eow = 1 << _S_not_eow;
+
+ /// If more than one match is possible then any match is an acceptable
+ /// result.
+ static const match_flag_type match_any = 1 << _S_any;
+
+ /// The expression does not match an empty sequence.
+ static const match_flag_type match_not_null = 1 << _S_not_null;
+
+ /// The expression only matchs a sub-sequence that begins at first .
+ static const match_flag_type match_continuous = 1 << _S_continuous;
+
+ /// --first is a valid iterator position. When this flag is set then the
+ /// flags match_not_bol and match_not_bow are ignored by the regular
+ /// expression algorithms 7.11 and iterators 7.12.
+ static const match_flag_type match_prev_avail = 1 << _S_prev_avail;
+
+ /// When a regular expression match is to be replaced by a new string, the
+ /// new string is constructed using the rules used by the ECMAScript replace
+ /// function in ECMA- 262 [Ecma International, ECMAScript Language
+ /// Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
+ /// String.prototype.replace. In addition, during search and replace
+ /// operations all non-overlapping occurrences of the regular expression
+ /// are located and replaced, and sections of the input that did not match
+ /// the expression are copied unchanged to the output string.
+ ///
+ /// Format strings (from ECMA-262 [15.5.4.11]):
+ /// $$ $
+ /// $& The matched substring.
+ /// $` The portion of <em>string</em> that preceeds the matched substring.
+ /// $' The portion of <em>string</em> that follows the matched substring.
+ /// $n The nth capture, where n is in [1,9] and $n is not followed by a
+ /// decimal digit. If n <= m and the nth capture is undefined, use the
+ /// empty string
+ /// instead. If n > m, the result is implementation-defined.
+ /// $nn The nnth capture, where nn is a two-digit decimal number on [01, 99].
+ /// If nn <= m and the nth capture is undefined, use the empty string
+ /// instead. If nn > m, the result is implementation-defined.
+ ///
+ static const match_flag_type format_default = 0;
+
+ /// When a regular expression match is to be replaced by a new string, the
+ /// new string is constructed using the rules used by the POSIX sed utility
+ /// in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
+ /// Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+ static const match_flag_type format_sed = 1 << _S_sed;
+
+ /// During a search and replace operation, sections of the character
+ /// container sequence being searched that do not match the regular
+ /// expression shall not be copied to the output string.
+ static const match_flag_type format_no_copy = 1 << _S_no_copy;
+
+ /// When specified during a search and replace operation, only the first
+ /// occurrence of the regular expression shall be replaced.
+ static const match_flag_type format_first_only = 1 << _S_first_only;
+
+
+ // [7.5.3] implementation-defined error type
+ enum error_type
+ {
+ _S_error_collate,
+ _S_error_ctype,
+ _S_error_escape,
+ _S_error_backref,
+ _S_error_brack,
+ _S_error_paren,
+ _S_error_brace,
+ _S_error_badbrace,
+ _S_error_range,
+ _S_error_space,
+ _S_error_badrepeat,
+ _S_error_complexity,
+ _S_error_stack,
+ _S_error_last
+ };
+
+ /// The expression contained an invalid collating element name.
+ static const error_type error_collate(_S_error_collate);
+
+ /// The expression contained an invalid character class name.
+ static const error_type error_ctype(_S_error_ctype);
+
+ /// The expression contained an invalid escaped character, or a trailing
+ /// escape.
+ static const error_type error_escape(_S_error_escape);
+
+ /// The expression contained an invalid back reference.
+ static const error_type error_backref(_S_error_backref);
+
+ /// The expression contained mismatched [ and ].
+ static const error_type error_brack(_S_error_brack);
+
+ /// The expression contained mismatched ( and ).
+ static const error_type error_paren(_S_error_paren);
+
+ /// The expression contained mismatched { and }
+ static const error_type error_brace(_S_error_brace);
+
+ /// The expression contained an invalid range in a {} expression.
+ static const error_type error_badbrace(_S_error_badbrace);
+
+ /// The expression contained an invalid character range,
+ /// such as [b-a] in most encodings.
+ static const error_type error_range(_S_error_range);
+
+ /// There was insufficient memory to convert the expression into a
+ /// finite state machine.
+ static const error_type error_space(_S_error_space);
+
+ /// One of *?+{ was not preceded by a valid regular expression.
+ static const error_type error_badrepeat(_S_error_badrepeat);
+
+ /// The complexity of an attempted match against a regular expression
+ /// exceeded a pre-set level.
+ static const error_type error_complexity(_S_error_complexity);
+
+ /// There was insufficient memory to determine whether the
+ /// regular expression could match the specified character sequence.
+ static const error_type error_stack(_S_error_stack);
+}
+
+
+ // [7.8] Class regex_error
+ /**
+ * Defines the type of objects thrown as exceptions to report errors from the
+ * regular expression library.
+ */
+ class regex_error
+ : public std::runtime_error
+ {
+ public:
+ /**
+ * @brief constructs a regex_error object.
+ *
+ * @param ecode the regex error code.
+ */
+ explicit
+ regex_error(regex_constants::error_type __ecode)
+ : std::runtime_error("regex_error"), _M_code(__ecode)
+ { }
+
+ /**
+ * @brief gets the regex error code.
+ *
+ * @returns the regex error code.
+ */
+ regex_constants::error_type
+ code() const
+ { return _M_code; }
+
+ protected:
+ regex_constants::error_type _M_code;
+ };
+
+
+ // [7.7] Class regex_traits
+ /**
+ * A regular expression traits class that satisfies the requirements of tr1
+ * section [7.2].
+ *
+ * The class %regex is parameterized around a set of related types and
+ * functions used to complete the definition of its semantics. This class
+ * satisfies the requirements of such a traits class.
+ */
+ template<typename _Ch_type>
+ struct regex_traits
+ {
+ public:
+ typedef _Ch_type char_type;
+ typedef std::basic_string<char_type> string_type;
+ typedef std::locale locale_type;
+ typedef std::ctype_base::mask char_class_type;
+
+ public:
+ /**
+ * @brief Constructs a default traits object.
+ */
+ regex_traits()
+ { }
+
+ /**
+ * @brief Gives the length of a C-style string starting at @p __p.
+ *
+ * @param __p a pointer to the start of a character sequence.
+ *
+ * @returns the number of characters between @p *__p and the first
+ * default-initialized value of type @p char_type. In other words, uses
+ * the C-string algorithm for determiining the length of a sequence of
+ * characters.
+ */
+ static std::size_t
+ length(const char_type* __p)
+ { return string_type::traits_type::length(__p); }
+
+ /**
+ * @brief Performs the identity translation.
+ *
+ * @param c A character to the locale-specific character set.
+ *
+ * @returns c.
+ */
+ char_type
+ translate(char_type __c) const
+ { return __c; }
+
+ /**
+ * @brief Translates a character into a case-insensitive equivalent.
+ *
+ * @param c A character to the locale-specific character set.
+ *
+ * @returns the locale-specific lower-case equivalent of c.
+ * @throws std::bad_cast if the imbued locale does not support the ctype
+ * facet.
+ */
+ char_type
+ translate_nocase(char_type __c) const
+ {
+ using std::ctype;
+ using std::use_facet;
+ return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
+ }
+
+ /**
+ * @brief Gets a sort key for a character sequence.
+ *
+ * @param first beginning of the character sequence.
+ * @param last one-past-the-end of the character sequence.
+ *
+ * Returns a sort key for the character sequence designated by the
+ * iterator range [F1, F2) such that if the character sequence [G1, G2)
+ * sorts before the character sequence [H1, H2) then
+ * v.transform(G1, G2) < v.transform(H1, H2).
+ *
+ * What this really does is provide a more efficient way to compare a
+ * string to multiple other strings in locales with fancy collation
+ * rules and equivalence classes.
+ *
+ * @returns a locale-specific sort key equivalent to the input range.
+ *
+ * @throws std::bad_cast if the current locale does not have a collate
+ * facet.
+ */
+ template<typename _Fwd_iter>
+ string_type
+ transform(_Fwd_iter __first, _Fwd_iter __last) const
+ {
+ using std::collate;
+ using std::use_facet;
+ const collate<_Ch_type>& __c(use_facet<
+ collate<_Ch_type> >(_M_locale));
+ string_type __s(__first, __last);
+ return __c.transform(__s.data(), __s.data() + __s.size());
+ }
+
+ /**
+ * @brief Dunno.
+ *
+ * @param first beginning of the character sequence.
+ * @param last one-past-the-end of the character sequence.
+ *
+ * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
+ * typeid(collate_byname<_Ch_type>) and the form of the sort key
+ * returned by collate_byname<_Ch_type>::transform(first, last) is known
+ * and can be converted into a primary sort key then returns that key,
+ * otherwise returns an empty string. WTF??
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Fwd_iter>
+ string_type
+ transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
+ { return string_type(); }
+
+ /**
+ * @breief Gets a collation element by name.
+ *
+ * @param first beginning of the collation element name.
+ * @param last one-past-the-end of the collation element name.
+ *
+ * @returns a sequence of one or more characters that represents the
+ * collating element consisting of the character sequence designated by
+ * the iterator range [first, last). Returns an empty string if the
+ * character sequence is not a valid collating element.
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Fwd_iter>
+ string_type
+ lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
+ { return string_type(); }
+
+ /**
+ * @brief Maps one or mire characters to a named character
+ * classification.
+ *
+ * @param first beginning of the character sequence.
+ * @param last one-past-the-end of the character sequence.
+ *
+ * @returns an unspecified value that represents the character
+ * classification named by the character sequence designated by the
+ * iterator range [first, last). The value returned shall be independent
+ * of the case of the characters in the character sequence. If the name
+ * is not recognized then returns a value that compares equal to 0.
+ *
+ * At least the following names (or their wide-character equivalent) are
+ * supported.
+ * - d
+ * - w
+ * - s
+ * - alnum
+ * - alpha
+ * - blank
+ * - cntrl
+ * - digit
+ * - graph
+ * - lower
+ * - print
+ * - punct
+ * - space
+ * - upper
+ * - xdigit
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Fwd_iter>
+ char_class_type
+ lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const
+ { return 0; }
+
+ /**
+ * @brief Determines if @p c is a member of an identified class.
+ *
+ * @param c a character.
+ * @param f a class type (as returned from lookup_classname).
+ *
+ * @returns true if the character @p c is a member of the classification
+ * represented by @p f, false otherwise.
+ *
+ * @throws std::bad_cast if the current locale does not have a ctype
+ * facet.
+ */
+ bool
+ isctype(_Ch_type __c, char_class_type __f) const
+ {
+ using std::ctype;
+ using std::use_facet;
+ const ctype<_Ch_type>& __ctype(use_facet<
+ ctype<_Ch_type> >(_M_locale));
+
+ if (__ctype.is(__c, __f))
+ return true;
+
+ // special case of underscore in [[:w:]]
+ if (__c == __ctype.widen('_'))
+ {
+ const char* const __wb[] = "w";
+ char_class_type __wt = this->lookup_classname(__wb,
+ __wb + sizeof(__wb));
+ if (__f | __wt)
+ return true;
+ }
+
+ // special case of [[:space:]] in [[:blank:]]
+ if (__c == __ctype.isspace(__c))
+ {
+ const char* const __bb[] = "blank";
+ char_class_type __bt = this->lookup_classname(__bb,
+ __bb + sizeof(__bb));
+ if (__f | __bt)
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * @brief Converts a digit to an int.
+ *
+ * @param ch a character representing a digit.
+ * @param radix the radix if the numeric conversion (limited to 8, 10,
+ * or 16).
+ *
+ * @returns the value represented by the digit ch in base radix if the
+ * character ch is a valid digit in base radix; otherwise returns -1.
+ *
+ * @todo Implement this function.
+ */
+ int
+ value(_Ch_type __ch, int __radix) const;
+
+ /**
+ * @brief Imbues the regex_traits object with a copy of a new locale.
+ *
+ * @param loc A locale.
+ *
+ * @returns a copy of the previous locale in use by the regex_traits
+ * object.
+ *
+ * @note Calling imbue with a different locale than the one currently in
+ * use invalidates all cached data held by *this.
+ */
+ locale_type
+ imbue(locale_type __loc)
+ {
+ std::swap(_M_locale, __loc);
+ return __loc;
+ }
+
+ /**
+ * @brief Gets a copy of the current locale in use by the regex_traits
+ * object.
+ */
+ locale_type
+ getloc() const
+ { return _M_locale; }
+
+ protected:
+ locale_type _M_locale;
+ };
+
+
+ // [7.8] Class basic_regex
+ /**
+ * Objects of specializations of this class represent regular expressions
+ * constructed from sequences of character type @p _Ch_type.
+ *
+ * Storage for the regular expression is allocated and deallocated as
+ * necessary by the member functions of this class.
+ */
+ template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
+ class basic_regex
+ {
+ public:
+ // types:
+ typedef _Ch_type value_type;
+ typedef regex_constants::syntax_option_type flag_type;
+ typedef typename _Rx_traits::locale_type locale_type;
+ typedef typename _Rx_traits::string_type string_type;
+
+ // [7.8.1] constants
+ static const regex_constants::syntax_option_type icase
+ = regex_constants::icase;
+ static const regex_constants::syntax_option_type nosubs
+ = regex_constants::nosubs;
+ static const regex_constants::syntax_option_type optimize
+ = regex_constants::optimize;
+ static const regex_constants::syntax_option_type collate
+ = regex_constants::collate;
+ static const regex_constants::syntax_option_type ECMAScript
+ = regex_constants::ECMAScript;
+ static const regex_constants::syntax_option_type basic
+ = regex_constants::basic;
+ static const regex_constants::syntax_option_type extended
+ = regex_constants::extended;
+ static const regex_constants::syntax_option_type awk
+ = regex_constants::awk;
+ static const regex_constants::syntax_option_type grep
+ = regex_constants::grep;
+ static const regex_constants::syntax_option_type egrep
+ = regex_constants::egrep;
+
+ // [7.8.2] construct/copy/destroy
+ /**
+ * Constructs a basic regular expression that does not match any
+ * character sequence.
+ */
+ basic_regex()
+ : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
+ { _M_compile(); }
+
+ /**
+ * @brief Constructs a basic regular expression from the sequence
+ * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
+ * flags in @p f.
+ *
+ * @param p A pointer to the start of a C-style null-terminated string
+ * containing a regular expression.
+ * @param f Flags indicating the syntax rules and options.
+ *
+ * @throws regex_error if @p p is not a valid regular expression.
+ */
+ explicit
+ basic_regex(const _Ch_type* __p,
+ flag_type __f = regex_constants::ECMAScript)
+ : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
+ { _M_compile(); }
+
+ /**
+ * @brief Constructs a basic regular expression from the sequence
+ * [p, p + len) interpreted according to the flags in @p f.
+ *
+ * @param p A pointer to the start of a string containing a regular
+ * expression.
+ * @param len The length of the string containing the regular expression.
+ * @param f Flags indicating the syntax rules and options.
+ *
+ * @throws regex_error if @p p is not a valid regular expression.
+ */
+ basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
+ : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
+ { _M_compile(); }
+
+ /**
+ * @brief Copy-contructs a basic regular expression.
+ *
+ * @param rhs A @p regex object.
+ */
+ basic_regex(const basic_regex& __rhs)
+ : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
+ _M_mark_count(__rhs._M_mark_count)
+ { _M_compile(); }
+
+ /**
+ * @brief Constructs a basic regular expression from the string
+ * @p interpreted according to the flags in @p f.
+ *
+ * @param p A string containing a regular expression.
+ * @param f Flags indicating the syntax rules and options.
+ *
+ * @throws regex_error if @p p is not a valid regular expression.
+ */
+ template<typename _Ch_traits, typename _Ch_alloc>
+ explicit
+ basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+ flag_type __f = regex_constants::ECMAScript)
+ : _M_flags(__f), _M_pattern(__s), _M_mark_count(0)
+ { _M_compile(); }
+
+ /**
+ * @brief Constructs a basic regular expression from the range
+ * [first, last) interpreted according to the flags in @p f.
+ *
+ * @param first The start of arange containing a valid regular
+ * expression.
+ * @param last The end of a range containing a valid regular
+ * expression.
+ * @param f The format flags of the regular expression.
+ *
+ * @throws regex_error if @p p is not a valid regular expression.
+ */
+ template<typename _InputIterator>
+ basic_regex(_InputIterator __first, _InputIterator __last,
+ flag_type __f = regex_constants::ECMAScript)
+ : _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
+ { _M_compile(); }
+
+ /**
+ * @brief Destroys a basic regular expression.
+ */
+ ~basic_regex()
+ { }
+
+ /**
+ * @brief Assigns one regular expression to another.
+ */
+ basic_regex&
+ operator=(const basic_regex& __rhs)
+ { return this->assign(__rhs); }
+
+ /**
+ * @brief Replaces a regular expression with a new one constructed from
+ * a C-style null-terminated string.
+ *
+ * @param A pointer to the start of a null-terminated C-style string
+ * containing a regular expression.
+ */
+ basic_regex&
+ operator=(const _Ch_type* __p)
+ { return this->assign(__p, flags()); }
+
+ /**
+ * @brief Replaces a regular expression with a new one constructed from
+ * a string.
+ *
+ * @param A pointer to a string containing a regular expression.
+ */
+ template<typename _Ch_typeraits, typename _Allocator>
+ basic_regex&
+ operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
+ { return this->assign(__s, flags()); }
+
+ // [7.8.3] assign
+ /**
+ * @brief the real assignment operator.
+ *
+ * @param that Another regular expression object.
+ */
+ basic_regex&
+ assign(const basic_regex& __that)
+ {
+ basic_regex __tmp(__that);
+ this->swap(__tmp);
+ return *this;
+ }
+
+ /**
+ * @brief Assigns a new regular expression to a regex object from a
+ * C-style null-terminated string containing a regular expression
+ * pattern.
+ *
+ * @param p A pointer to a C-style null-terminated string containing
+ * a regular expression pattern.
+ * @param flags Syntax option flags.
+ *
+ * @throws regex_error if p does not contain a valid regular expression
+ * pattern interpreted according to @p flags. If regex_error is thrown,
+ * *this remains unchanged.
+ */
+ basic_regex&
+ assign(const _Ch_type* __p,
+ flag_type __flags = regex_constants::ECMAScript)
+ { return this->assign(string_type(__p), __flags); }
+
+ /**
+ * @brief Assigns a new regular expression to a regex object from a
+ * C-style string containing a regular expression pattern.
+ *
+ * @param p A pointer to a C-style string containing a
+ * regular expression pattern.
+ * @param len The length of the regular expression pattern string.
+ * @param flags Syntax option flags.
+ *
+ * @throws regex_error if p does not contain a valid regular expression
+ * pattern interpreted according to @p flags. If regex_error is thrown,
+ * *this remains unchanged.
+ */
+ basic_regex&
+ assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
+ { return this->assign(string_type(__p, __len), __flags); }
+
+ /**
+ * @brief Assigns a new regular expression to a regex object from a
+ * string containing a regular expression pattern.
+ *
+ * @param s A string containing a regular expression pattern.
+ * @param flags Syntax option flags.
+ *
+ * @throws regex_error if p does not contain a valid regular expression
+ * pattern interpreted according to @p flags. If regex_error is thrown,
+ * *this remains unchanged.
+ */
+ template<typename _Ch_typeraits, typename _Allocator>
+ basic_regex&
+ assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
+ flag_type __f = regex_constants::ECMAScript)
+ {
+ basic_regex __tmp(__s, __f);
+ this->swap(__tmp);
+ return *this;
+ }
+
+ /**
+ * @brief Assigns a new regular expression to a regex object.
+ *
+ * @param first The start of a range containing a valid regular
+ * expression.
+ * @param last The end of a range containing a valid regular
+ * expression.
+ * @param flags Syntax option flags.
+ *
+ * @throws regex_error if p does not contain a valid regular expression
+ * pattern interpreted according to @p flags. If regex_error is thrown,
+ * *this remains unchanged.
+ */
+ template<typename _InputIterator>
+ basic_regex&
+ assign(_InputIterator __first, _InputIterator __last,
+ flag_type __flags = regex_constants::ECMAScript)
+ { return this->assign(string_type(__first, __last), __flags); }
+
+ // [7.8.4] const operations
+ /**
+ * @brief Gets the number of marked subexpressions within the regular
+ * expresison.
+ */
+ unsigned int
+ mark_count() const
+ { return _M_mark_count; }
+
+ /**
+ * @brief Gets the flags used to construct the regular expression
+ * or in the last call to assign().
+ */
+ flag_type
+ flags() const
+ { return _M_flags; }
+
+ // [7.8.5] locale
+ /**
+ * @brief Imbues the regular expression object with the given locale.
+ *
+ * @param loc A locale.
+ */
+ locale_type
+ imbue(locale_type __loc)
+ { return _M_traits.imbue(__loc); }
+
+ /**
+ * @brief Gets the locale currently imbued in the regular expression
+ * object.
+ */
+ locale_type
+ getloc() const
+ { return _M_traits.getloc(); }
+
+ // [7.8.6] swap
+ /**
+ * @brief Swaps the contents of two regular expression obects.
+ *
+ * @param rhs Another regular expression object.
+ */
+ void
+ swap(basic_regex& __rhs)
+ {
+ std::swap(_M_flags, __rhs._M_flags);
+ std::swap(_M_pattern, __rhs._M_pattern);
+ std::swap(_M_mark_count, __rhs._M_mark_count);
+ std::swap(_M_traits, __rhs._M_traits);
+ }
+
+ private:
+ /**
+ * @brief Compiles a regular expression pattern into a NFA.
+ * @todo Implement this function.
+ */
+ void _M_compile()
+ { }
+
+ protected:
+ flag_type _M_flags;
+ string_type _M_pattern;
+ unsigned int _M_mark_count;
+ _Rx_traits _M_traits;
+ };
+
+ typedef basic_regex<char> regex;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ typedef basic_regex<wchar_t> wregex;
+#endif
+
+
+ // [7.8.6] basic_regex swap
+ /**
+ * @brief Swaps the contents of two regular expression objects.
+ * @param lhs First regular expression.
+ * @param rhs Second regular expression.
+ */
+ template<typename _Ch_type, typename _Rx_traits>
+ inline void
+ swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
+ basic_regex<_Ch_type, _Rx_traits>& __rhs)
+ { return __lhs.swap(__rhs); }
+
+
+ // [7.9] Class template sub_match
+ /**
+ * A sequence of characters matched by a particular marked sub-expression.
+ *
+ * An object of this class is essentially a pair of iterators marking a
+ * matched subexpression within a regular expression pattern match. Such
+ * objects can be converted to and compared with std::basic_string objects
+ * of a similar base character type as the pattern matched by the regular
+ * expression.
+ *
+ * The iterators that make up the pair are the usual half-open interval
+ * referencing the actual original pattern matched.
+ */
+ template<typename _BiIter>
+ class sub_match : public std::pair<_BiIter, _BiIter>
+ {
+ public:
+ typedef typename iterator_traits<_BiIter>::value_type value_type;
+ typedef typename iterator_traits<_BiIter>::difference_type
+ difference_type;
+ typedef _BiIter iterator;
+
+ public:
+ bool matched;
+
+ /**
+ * Gets the length of the matching sequence.
+ */
+ difference_type
+ length() const
+ { return this->matched ? std::distance(this->first, this->second) : 0; }
+
+ /**
+ * @brief Gets the matching sequence as a string.
+ *
+ * @returns the matching sequence as a string.
+ *
+ * This is the implicit conversion operator. It is identical to the
+ * str() member function except that it will want to pop up in
+ * unexpected places and cause a great deal of confusion and cursing
+ * from the unwary.
+ */
+ operator basic_string<value_type>() const
+ {
+ return this->matched
+ ? std::basic_string<value_type>(this->first, this->second)
+ : std::basic_string<value_type>();
+ }
+
+ /**
+ * @brief Gets the matching sequence as a string.
+ *
+ * @returns the matching sequence as a string.
+ */
+ basic_string<value_type>
+ str() const
+ {
+ return this->matched
+ ? std::basic_string<value_type>(this->first, this->second)
+ : std::basic_string<value_type>();
+ }
+
+ /**
+ * @brief Compares this and another matched sequence.
+ *
+ * @param s Another matched sequence to compare to this one.
+ *
+ * @retval <0 this matched sequence will collate before @p s.
+ * @retval =0 this matched sequence is equivalent to @p s.
+ * @retval <0 this matched sequence will collate after @p s.
+ */
+ int
+ compare(const sub_match& __s) const
+ { return this->str().compare(__s.str()); }
+
+ /**
+ * @brief Compares this sub_match to a string.
+ *
+ * @param s A string to compare to this sub_match.
+ *
+ * @retval <0 this matched sequence will collate before @p s.
+ * @retval =0 this matched sequence is equivalent to @p s.
+ * @retval <0 this matched sequence will collate after @p s.
+ */
+ int
+ compare(const basic_string<value_type>& __s) const
+ { return this->str().compare(__s); }
+
+ /**
+ * @brief Compares this sub_match to a C-style string.
+ *
+ * @param s A C-style string to compare to this sub_match.
+ *
+ * @retval <0 this matched sequence will collate before @p s.
+ * @retval =0 this matched sequence is equivalent to @p s.
+ * @retval <0 this matched sequence will collate after @p s.
+ */
+ int
+ compare(const value_type* __s) const
+ { return this->str().compare(__s); }
+ };
+
+
+ typedef sub_match<const char*> csub_match;
+ typedef sub_match<string::const_iterator> ssub_match;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ typedef sub_match<const wchar_t*> wcsub_match;
+ typedef sub_match<wstring::const_iterator> wssub_match;
+#endif
+
+ // [7.9.2] sub_match non-member operators
+
+ /**
+ * @brief Tests the equivalence of two regular expression submatches.
+ * @param lhs First regular expression submatch.
+ * @param rhs Second regular expression submatch.
+ * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+ */
+ template<typename _BiIter>
+ inline bool
+ operator==(const sub_match<_BiIter>& __lhs,
+ const sub_match<_BiIter>& __rhs)
+ { return __lhs.compare(__rhs) == 0; }
+
+ /**
+ * @brief Tests the inequivalence of two regular expression submatches.
+ * @param lhs First regular expression submatch.
+ * @param rhs Second regular expression submatch.
+ * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+ */
+ template<typename _BiIter>
+ inline bool
+ operator!=(const sub_match<_BiIter>& __lhs,
+ const sub_match<_BiIter>& __rhs)
+ { return __lhs.compare(__rhs) != 0; }
+
+ /**
+ * @brief Tests the ordering of two regular expression submatches.
+ * @param lhs First regular expression submatch.
+ * @param rhs Second regular expression submatch.
+ * @returns true if @a lhs precedes @a rhs, false otherwise.
+ */
+ template<typename _BiIter>
+ inline bool
+ operator<(const sub_match<_BiIter>& __lhs,
+ const sub_match<_BiIter>& __rhs)
+ { return __lhs.compare(__rhs) < 0; }
+
+ /**
+ * @brief Tests the ordering of two regular expression submatches.
+ * @param lhs First regular expression submatch.
+ * @param rhs Second regular expression submatch.
+ * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+ */
+ template<typename _BiIter>
+ inline bool
+ operator<=(const sub_match<_BiIter>& __lhs,
+ const sub_match<_BiIter>& __rhs)
+ { return __lhs.compare(__rhs) <= 0; }
+
+ /**
+ * @brief Tests the ordering of two regular expression submatches.
+ * @param lhs First regular expression submatch.
+ * @param rhs Second regular expression submatch.
+ * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ */
+ template<typename _BiIter>
+ inline bool
+ operator>=(const sub_match<_BiIter>& __lhs,
+ const sub_match<_BiIter>& __rhs)
+ { return __lhs.compare(__rhs) >= 0; }
+
+ /**
+ * @brief Tests the ordering of two regular expression submatches.
+ * @param lhs First regular expression submatch.
+ * @param rhs Second regular expression submatch.
+ * @returns true if @a lhs succeeds @a rhs, false otherwise.
+ */
+ template<typename _BiIter>
+ inline bool
+ operator>(const sub_match<_BiIter>& __lhs,
+ const sub_match<_BiIter>& __rhs)
+ { return __lhs.compare(__rhs) > 0; }
+
+ /**
+ * @brief Tests the equivalence of a string and a regular expression
+ * submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator==(const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs == __rhs.str(); }
+
+ /**
+ * @brief Tests the inequivalence of a string and a regular expression
+ * submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator!=(const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+ { return __lhs != __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs precedes @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator<(const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+ { return __lhs < __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs succeeds @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator>(const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+ { return __lhs > __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator>=(const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+ { return __lhs >= __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator<=(const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+ { return __lhs <= __rhs.str(); }
+
+ /**
+ * @brief Tests the equivalence of a regular expression submatch and a
+ * string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator==(const sub_match<_Bi_iter>& __lhs,
+ const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __rhs)
+ { return __lhs.str() == __rhs; }
+
+ /**
+ * @brief Tests the inequivalence of a regular expression submatch and a
+ * string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ inline bool
+ operator!=(const sub_match<_Bi_iter>& __lhs,
+ const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __rhs)
+ { return __lhs.str() != __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs precedes @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ inline bool
+ operator<(const sub_match<_Bi_iter>& __lhs,
+ const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __rhs)
+ { return __lhs.str() < __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs succeeds @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ inline bool
+ operator>(const sub_match<_Bi_iter>& __lhs,
+ const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __rhs)
+ { return __lhs.str() > __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ inline bool
+ operator>=(const sub_match<_Bi_iter>& __lhs,
+ const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __rhs)
+ { return __lhs.str() >= __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ inline bool
+ operator<=(const sub_match<_Bi_iter>& __lhs,
+ const basic_string<
+ typename iterator_traits<_Bi_iter>::value_type,
+ _Ch_traits, _Ch_alloc>& __rhs)
+ { return __lhs.str() <= __rhs; }
+
+ /**
+ * @brief Tests the equivalence of a C string and a regular expression
+ * submatch.
+ * @param lhs A C string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs == __rhs.str(); }
+
+ /**
+ * @brief Tests the inequivalence of an iterator value and a regular
+ * expression submatch.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs != __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs precedes @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs < __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs succeeds @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs > __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs >= __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs <= __rhs.str(); }
+
+ /**
+ * @brief Tests the equivalence of a regular expression submatch and a
+ * string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A pointer to a string?
+ * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator==(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+ { return __lhs.str() == __rhs; }
+
+ /**
+ * @brief Tests the inequivalence of a regular expression submatch and a
+ * string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A pointer to a string.
+ * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator!=(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+ { return __lhs.str() != __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs precedes @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+ { return __lhs.str() < __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs succeeds @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+ { return __lhs.str() > __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>=(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+ { return __lhs.str() >= __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A string.
+ * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<=(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+ { return __lhs.str() <= __rhs; }
+
+ /**
+ * @brief Tests the equivalence of a string and a regular expression
+ * submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs == __rhs.str(); }
+
+ /**
+ * @brief Tests the inequivalence of a string and a regular expression
+ * submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs != __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs precedes @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs < __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs succeeds @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs > __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs >= __rhs.str(); }
+
+ /**
+ * @brief Tests the ordering of a string and a regular expression submatch.
+ * @param lhs A string.
+ * @param rhs A regular expression submatch.
+ * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+ const sub_match<_Bi_iter>& __rhs)
+ { return __lhs <= __rhs.str(); }
+
+ /**
+ * @brief Tests the equivalence of a regular expression submatch and a
+ * string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A const string reference.
+ * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator==(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+ { return __lhs.str() == __rhs; }
+
+ /**
+ * @brief Tests the inequivalence of a regular expression submatch and a
+ * string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A const string reference.
+ * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator!=(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+ { return __lhs.str() != __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A const string reference.
+ * @returns true if @a lhs preceeds @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+ { return __lhs.str() < __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A const string reference.
+ * @returns true if @a lhs succeeds @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+ { return __lhs.str() > __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A const string reference.
+ * @returns true if @a lhs does not preceed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator>=(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+ { return __lhs.str() >= __rhs; }
+
+ /**
+ * @brief Tests the ordering of a regular expression submatch and a string.
+ * @param lhs A regular expression submatch.
+ * @param rhs A const string reference.
+ * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ inline bool
+ operator<=(const sub_match<_Bi_iter>& __lhs,
+ typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+ { return __lhs.str() <= __rhs; }
+
+ /**
+ * @brief Inserts a matched string into an output stream.
+ *
+ * @param os The output stream.
+ * @param m A submatch string.
+ *
+ * @returns the output stream with the submatch string inserted.
+ */
+ template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
+ inline
+ basic_ostream<_Ch_type, _Ch_traits>&
+ operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
+ const sub_match<_Bi_iter>& __m)
+ { return __os << __m.str(); }
+
+ // [7.10] Class template match_results
+ /**
+ * A collection of character sequences representing the result of a regular
+ * expression match. Storage for the collection is allocated and freed as
+ * necessary by the member functions of class template match_results.
+ *
+ * This class satisfies the Sequence requirements, with the exception that
+ * only the operations defined for a const-qualified Sequence are supported.
+ *
+ * The sub_match object stored at index 0 represents sub-expression 0, i.e.
+ * the whole match. In this case the sub_match member matched is always true.
+ * The sub_match object stored at index n denotes what matched the marked
+ * sub-expression n within the matched expression. If the sub-expression n
+ * participated in a regular expression match then the sub_match member
+ * matched evaluates to true, and members first and second denote the range
+ * of characters [first, second) which formed that match. Otherwise matched
+ * is false, and members first and second point to the end of the sequence
+ * that was searched.
+ */
+ template<typename _Bi_iter,
+ typename _Allocator = allocator<sub_match<_Bi_iter> > >
+ class match_results
+ : private std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
+ {
+ private:
+ typedef std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
+ _Base_type;
+
+ public:
+ typedef sub_match<_Bi_iter> value_type;
+ typedef typename _Allocator::const_reference const_reference;
+ typedef const_reference reference;
+ typedef typename _Base_type::const_iterator const_iterator;
+ typedef const_iterator iterator;
+ typedef typename iterator_traits<_Bi_iter>::difference_type
+ difference_type;
+ typedef typename _Allocator::size_type size_type;
+ typedef _Allocator allocator_type;
+ typedef typename iterator_traits<_Bi_iter>::value_type char_type;
+ typedef basic_string<char_type> string_type;
+
+ public:
+ // [7.10.1] construct/copy/destroy
+ /**
+ * @brief Constructs a default match_results container.
+ */
+ explicit
+ match_results(const _Allocator& __a = _Allocator())
+ : _Base_type(__a), _M_matched(false)
+ { }
+
+ /**
+ * @brief Copy constructs a match_result.
+ */
+ match_results(const match_results& __rhs)
+ : _Base_type(__rhs), _M_matched(__rhs._M_matched),
+ _M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
+ { }
+
+ /**
+ * @brief Assigns rhs to *this.
+ */
+ match_results&
+ operator=(const match_results& __rhs)
+ {
+ match_results __tmp(__rhs);
+ this->swap(__tmp);
+ }
+
+ /**
+ * @todo Implement this function.
+ */
+ ~match_results()
+ { }
+
+ // [7.10.2] size
+ /**
+ * @todo Document this function.
+ */
+ size_type
+ size() const
+ { return _M_matched ? _Base_type::size() + 1 : 0; }
+
+ /**
+ * @todo Implement this function.
+ */
+ //size_type
+ //max_size() const;
+ using _Base_type::max_size;
+
+ /**
+ * @todo Document this function.
+ */
+ bool
+ empty() const
+ { return size() == 0; }
+
+ // [7.10.3] element access
+ /**
+ * @brief Gets the length of the indicated submatch.
+ * @param sub indicates the submatch.
+ */
+ difference_type
+ length(size_type __sub = 0) const
+ { return _M_matched ? this->str(__sub).length() : 0; }
+
+ /**
+ * @todo Document this function.
+ */
+ difference_type
+ position(size_type __sub = 0) const
+ {
+ return _M_matched ? std::distance(this->prefix().first,
+ (*this)[__sub].first) : 0;
+ }
+
+ /**
+ * @todo Document this function.
+ */
+ string_type
+ str(size_type __sub = 0) const
+ { return _M_matched ? (*this)[__sub].str() : string_type(); }
+
+ /**
+ * @todo Document this function.
+ */
+ const_reference
+ operator[](size_type __n) const
+ { return _Base_type::operator[](__n); }
+
+ /**
+ * @todo Document this function.
+ */
+ const_reference
+ prefix() const
+ { return _M_prefix; }
+
+ /**
+ * @todo Document this function.
+ */
+ const_reference
+ suffix() const
+ { return _M_suffix; }
+
+ /**
+ * @todo Document this function.
+ */
+ const_iterator
+ begin() const
+ { return _Base_type::begin(); }
+
+ /**
+ * @todo Document this function.
+ */
+ const_iterator
+ end() const
+ { return _Base_type::end(); }
+
+ // [7.10.4] format
+ /**
+ * @todo Implement this function.
+ */
+ template<typename _Out_iter>
+ _Out_iter
+ format(_Out_iter __out, const string_type& __fmt,
+ regex_constants::match_flag_type __flags
+ = regex_constants::format_default) const
+ { return __out; }
+
+ /**
+ * @todo Implement this function.
+ */
+ string_type
+ format(const string_type& __fmt,
+ regex_constants::match_flag_type __flags
+ = regex_constants::format_default) const;
+
+ // [7.10.5] allocator
+ /**
+ * @todo Document this function.
+ */
+ //allocator_type
+ //get_allocator() const;
+ using _Base_type::get_allocator;
+
+ // [7.10.6] swap
+ /**
+ * @todo Document this function.
+ */
+ void
+ swap(match_results& __that)
+ {
+ _Base_type::swap(__that);
+ std::swap(_M_matched, __that._M_matched);
+ std::swap(_M_prefix, __that._M_prefix);
+ std::swap(_M_suffix, __that._M_suffix);
+ }
+
+ private:
+ bool _M_matched;
+ value_type _M_prefix;
+ value_type _M_suffix;
+ };
+
+ typedef match_results<const char*> cmatch;
+ typedef match_results<string::const_iterator> smatch;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ typedef match_results<const wchar_t*> wcmatch;
+ typedef match_results<wstring::const_iterator> wsmatch;
+#endif
+
+ // match_results comparisons
+ /**
+ * @todo Implement this function.
+ */
+ template<typename _Bi_iter, typename _Allocator>
+ inline bool
+ operator==(const match_results<_Bi_iter, _Allocator>& __m1,
+ const match_results<_Bi_iter, _Allocator>& __m2);
+
+ /**
+ * @todo Implement this function.
+ */
+ template<typename _Bi_iter, class _Allocator>
+ inline bool
+ operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
+ const match_results<_Bi_iter, _Allocator>& __m2);
+
+ // [7.10.6] match_results swap
+ /**
+ * @brief Swaps two match results.
+ * @param lhs A match result.
+ * @param rhs A match result.
+ *
+ * The contents of the two match_results objects are swapped.
+ */
+ template<typename _Bi_iter, typename _Allocator>
+ inline void
+ swap(match_results<_Bi_iter, _Allocator>& __lhs,
+ match_results<_Bi_iter, _Allocator>& __rhs)
+ { return __lhs.swap(__rhs); }
+
+ // [7.11.2] Function template regex_match
+ /**
+ * @brief Determines if there is a match between the regular expression @p e
+ * and all of the character sequence [first, last).
+ *
+ * @param first Beginning of the character sequence to match.
+ * @param last One-past-the-end of the character sequence to match.
+ * @param m The match results.
+ * @param re The regular expression.
+ * @param flags Controls how the regular expression is matched.
+ *
+ * @retval true A match exists.
+ * @retval false Otherwise.
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Bi_iter, typename _Allocator,
+ typename _Ch_type, typename _Rx_traits>
+ bool
+ regex_match(_Bi_iter __first, _Bi_iter __last,
+ match_results<_Bi_iter, _Allocator>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ { return false; }
+
+ /**
+ * @brief Indicates if there is a match between the regular expression @p e
+ * and all of the character sequence [first, last).
+ *
+ * @param first Beginning of the character sequence to match.
+ * @param last One-past-the-end of the character sequence to match.
+ * @param re The regular expression.
+ * @param flags Controls how the regular expression is matched.
+ *
+ * @retval true A match exists.
+ * @retval false Otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+ bool
+ regex_match(_Bi_iter __first, _Bi_iter __last,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ {
+ match_results<_Bi_iter> __what;
+ return regex_match(__first, __last, __what, __re, __flags);
+ }
+
+ /**
+ * @brief Determines if there is a match between the regular expression @p e
+ * and a C-style null-terminated string.
+ *
+ * @param s The C-style null-terminated string to match.
+ * @param m The match results.
+ * @param re The regular expression.
+ * @param f Controls how the regular expression is matched.
+ *
+ * @retval true A match exists.
+ * @retval false Otherwise.
+ */
+ template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
+ inline bool
+ regex_match(const _Ch_type* __s,
+ match_results<const _Ch_type*, _Allocator>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __f
+ = regex_constants::match_default)
+ { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
+
+ /**
+ * @brief Determines if there is a match between the regular expression @p e
+ * and a string.
+ *
+ * @param s The string to match.
+ * @param m The match results.
+ * @param re The regular expression.
+ * @param flags Controls how the regular expression is matched.
+ *
+ * @retval true A match exists.
+ * @retval false Otherwise.
+ */
+ template<typename _Ch_traits, typename _Ch_alloc,
+ typename _Allocator, typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+ match_results<typename basic_string<_Ch_type,
+ _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
+
+ /**
+ * @brief Indicates if there is a match between the regular expression @p e
+ * and a C-style null-terminated string.
+ *
+ * @param s The C-style null-terminated string to match.
+ * @param re The regular expression.
+ * @param f Controls how the regular expression is matched.
+ *
+ * @retval true A match exists.
+ * @retval false Otherwise.
+ */
+ template<typename _Ch_type, class _Rx_traits>
+ inline bool
+ regex_match(const _Ch_type* __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __f
+ = regex_constants::match_default)
+ { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
+
+ /**
+ * @brief Indicates if there is a match between the regular expression @p e
+ * and a string.
+ *
+ * @param s [IN] The string to match.
+ * @param re [IN] The regular expression.
+ * @param flags [IN] Controls how the regular expression is matched.
+ *
+ * @retval true A match exists.
+ * @retval false Otherwise.
+ */
+ template<typename _Ch_traits, typename _Str_allocator,
+ typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ { return regex_match(__s.begin(), __s.end(), __re, __flags); }
+
+ // [7.11.3] Function template regex_search
+ /**
+ * Searches for a regular expression within a range.
+ * @param first [IN] The start of the string to search.
+ * @param last [IN] One-past-the-end of the string to search.
+ * @param m [OUT] The match results.
+ * @param re [IN] The regular expression to search for.
+ * @param flags [IN] Search policy flags.
+ * @retval true A match was found within the string.
+ * @retval false No match was found within the string, the content of %m is
+ * undefined.
+ * @todo Implement this function.
+ */
+ template<typename _Bi_iter, typename _Allocator,
+ typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_search(_Bi_iter __first, _Bi_iter __last,
+ match_results<_Bi_iter, _Allocator>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ { return false; }
+
+ /**
+ * Searches for a regular expression within a range.
+ * @param first [IN] The start of the string to search.
+ * @param last [IN] One-past-the-end of the string to search.
+ * @param re [IN] The regular expression to search for.
+ * @param flags [IN] Search policy flags.
+ * @retval true A match was found within the string.
+ * @retval false No match was found within the string.
+ * @todo Document me.
+ */
+ template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_search(_Bi_iter __first, _Bi_iter __last,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ {
+ match_results<_Bi_iter> __what;
+ return regex_search(__first, __last, __what, __re, __flags);
+ }
+
+ /**
+ * @brief Searches for a regular expression within a C-string.
+ * @param s [IN] A C-string to search for the regex.
+ * @param m [OUT] The set of regex mnatches.
+ * @param e [IN] The regex to search for in @p s.
+ * @param f [IN] The search flags.
+ * @retval true A match was found within the string.
+ * @retval false No match was found within the string, the content of %m is
+ * undefined.
+ * @todo Document me.
+ */
+ template<typename _Ch_type, class _Allocator, class _Rx_traits>
+ inline bool
+ regex_search(const _Ch_type* __s,
+ match_results<const _Ch_type*, _Allocator>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ regex_constants::match_flag_type __f
+ = regex_constants::match_default)
+ { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
+
+ /**
+ * @brief Searches for a regular expression within a C-string.
+ * @param s [IN] The C-string to search.
+ * @param e [IN] The regular expressioon to search for.
+ * @param f [IN] Search policy flags.
+ * @retval true A match was found within the string.
+ * @retval false No match was found within the string.
+ * @todo Document me.
+ */
+ template<typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_search(const _Ch_type* __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ regex_constants::match_flag_type __f
+ = regex_constants::match_default)
+ { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
+
+ /**
+ * @brief Searches for a regular expression within a string.
+ * @param s [IN] The string to search.
+ * @param e [IN] The regular expressioon to search for.
+ * @param flags [IN] Search policy flags.
+ * @retval true A match was found within the string.
+ * @retval false No match was found within the string.
+ * @todo Document me.
+ */
+ template<typename _Ch_traits, typename _String_allocator,
+ typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_search(const basic_string<_Ch_type, _Ch_traits,
+ _String_allocator>& __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ { return regex_search(__s.begin(), __s.end(), __e, __flags); }
+
+ /**
+ * @brief Searches for a regular expression within a string.
+ * @param s [IN] A C++ string to search for the regex.
+ * @param m [OUT] The set of regex mnatches.
+ * @param e [IN] The regex to search for in @p s.
+ * @param f [IN] The search flags.
+ * @retval true A match was found within the string.
+ * @retval false No match was found within the string, the content of %m is
+ * undefined.
+ */
+ template<typename _Ch_traits, typename _Ch_alloc,
+ typename _Allocator, typename _Ch_type,
+ typename _Rx_traits>
+ inline bool
+ regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+ match_results<typename basic_string<_Ch_type,
+ _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ regex_constants::match_flag_type __f
+ = regex_constants::match_default)
+ { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
+
+ // [7.11.4] Function template regex_replace
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ template<typename _Out_iter, typename _Bi_iter,
+ typename _Rx_traits, typename _Ch_type>
+ inline _Out_iter
+ regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ const basic_string<_Ch_type>& __fmt,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ { return __out; }
+
+ /**
+ * @todo Document me.
+ */
+ template<typename _Rx_traits, typename _Ch_type>
+ inline basic_string<_Ch_type>
+ regex_replace(const basic_string<_Ch_type>& __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ const basic_string<_Ch_type>& __fmt,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ {
+ std::string __result;
+ regex_replace(std::back_inserter(__result),
+ __s.begin(), __s.end(), __e, __fmt, __flags);
+ return __result;
+ }
+
+ // [7.12.1] Class template regex_iterator
+ /**
+ * An iterator adaptor that will provide repeated calls of regex_search over
+ * a range until no more matches remain.
+ */
+ template<typename _Bi_iter,
+ typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+ typename _Rx_traits = regex_traits<_Ch_type> >
+ class regex_iterator
+ {
+ public:
+ typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
+ typedef match_results<_Bi_iter> value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type* pointer;
+ typedef const value_type& reference;
+ typedef std::forward_iterator_tag iterator_category;
+
+ public:
+ /**
+ * @brief Provides a singular iterator, useful for indicating
+ * one-past-the-end of a range.
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_iterator();
+
+ /**
+ * Constructs a %regex_iterator...
+ * @param a [IN] The start of a text range to search.
+ * @param b [IN] One-past-the-end of the text range to search.
+ * @param re [IN] The regular expression to match.
+ * @param m [IN] Policy flags for match rules.
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+ regex_constants::match_flag_type __m
+ = regex_constants::match_default);
+
+ /**
+ * Copy constructs a %regex_iterator.
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_iterator(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_iterator&
+ operator=(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ bool
+ operator==(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ bool
+ operator!=(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ const value_type&
+ operator*();
+
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ const value_type*
+ operator->();
+
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_iterator&
+ operator++();
+
+ /**
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_iterator
+ operator++(int);
+
+ private:
+ // these members are shown for exposition only:
+ _Bi_iter begin;
+ _Bi_iter end;
+ const regex_type* pregex;
+ regex_constants::match_flag_type flags;
+ match_results<_Bi_iter> match;
+ };
+
+ typedef regex_iterator<const char*> cregex_iterator;
+ typedef regex_iterator<string::const_iterator> sregex_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ typedef regex_iterator<const wchar_t*> wcregex_iterator;
+ typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
+#endif
+
+ // [7.12.2] Class template regex_token_iterator
+ /**
+ * Iterates over submatches in a range (or "splits" a text string).
+ *
+ * The purpose of this iterator is to enumerate all, or all specified,
+ * matches of a regular expression within a text range. The dereferenced
+ * value of an iterator of this class is a std::tr1::sub_match object.
+ */
+ template<typename _Bi_iter,
+ typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+ typename _Rx_traits = regex_traits<_Ch_type> >
+ class regex_token_iterator
+ {
+ public:
+ typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
+ typedef sub_match<_Bi_iter> value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type* pointer;
+ typedef const value_type& reference;
+ typedef std::forward_iterator_tag iterator_category;
+
+ public:
+ /**
+ * @brief Default constructs a %regex_token_iterator.
+ * @todo Implement this function.
+ *
+ * A default-constructed %regex_token_iterator is a singular iterator
+ * that will compare equal to the one-past-the-end value for any
+ * iterator of the same type.
+ */
+ regex_token_iterator();
+
+ /**
+ * Constrcts a %regex_token_iterator...
+ * @param a [IN] The start of the text to search.
+ * @param b [IN] One-past-the-eend of the text to search.
+ * @param re [IN] The regular expression to search for.
+ * @param submatch [IN] Which submatch to return. There are some
+ * special values for thsi parameter:
+ * - -1 each enumerated subexpression does NOT
+ * match the regular expression (aka field
+ * splitting)
+ * - 0 the entire string matching the
+ * subexpression is returned for each match
+ * within the text.
+ * - >0 enumerates only the indicated
+ * subexpression from a match within the text.
+ * @param m [IN] Policy flags for match rules.
+ *
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+ int __submatch = 0,
+ regex_constants::match_flag_type __m
+ = regex_constants::match_default);
+
+ /**
+ * Constrcts a %regex_token_iterator...
+ * @param a [IN] The start of the text to search.
+ * @param b [IN] One-past-the-eend of the text to search.
+ * @param re [IN] The regular expression to search for.
+ * @param submatches [IN] A list of subexpressions to return for each
+ * regular expression match within the text.
+ * @param m [IN] Policy flags for match rules.
+ *
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+ const regex_type& __re,
+ const std::vector<int>& __submatches,
+ regex_constants::match_flag_type __m
+ = regex_constants::match_default);
+
+ /**
+ * Constrcts a %regex_token_iterator...
+ * @param a [IN] The start of the text to search.
+ * @param b [IN] One-past-the-eend of the text to search.
+ * @param re [IN] The regular expression to search for.
+ * @param submatches [IN] A list of subexpressions to return for each
+ * regular expression match within the text.
+ * @param m [IN] Policy flags for match rules.
+
+ * @todo Implement this function.
+ * @todo Document this function.
+ */
+ template<std::size_t _Nm>
+ regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+ const regex_type& __re,
+ const int (&__submatches)[_Nm],
+ regex_constants::match_flag_type __m
+ = regex_constants::match_default);
+
+ /**
+ * @brief Copy constructs a %regex_token_iterator.
+ * @param rhs [IN] A %regex_token_iterator to copy.
+ * @todo Implement this function.
+ */
+ regex_token_iterator(const regex_token_iterator& __rhs);
+
+ /**
+ * @brief Assigns a %regex_token_iterator to another.
+ * @param rhs [IN] A %regex_token_iterator to copy.
+ * @todo Implement this function.
+ */
+ regex_token_iterator&
+ operator=(const regex_token_iterator& __rhs);
+
+ /**
+ * @brief Compares a %regex_token_iterator to another for equality.
+ * @todo Implement this function.
+ */
+ bool
+ operator==(const regex_token_iterator& __rhs);
+
+ /**
+ * @brief Compares a %regex_token_iterator to another for inequality.
+ * @todo Implement this function.
+ */
+ bool
+ operator!=(const regex_token_iterator& __rhs);
+
+ /**
+ * @brief Dereferences a %regex_token_iterator.
+ * @todo Implement this function.
+ */
+ const value_type&
+ operator*();
+
+ /**
+ * @brief Selects a %regex_token_iterator member.
+ * @todo Implement this function.
+ */
+ const value_type*
+ operator->();
+
+ /**
+ * @brief Increments a %regex_token_iterator.
+ * @todo Implement this function.
+ */
+ regex_token_iterator&
+ operator++();
+
+ /**
+ * @brief Postincrements a %regex_token_iterator.
+ * @todo Implement this function.
+ */
+ regex_token_iterator
+ operator++(int);
+
+ private: // data members for exposition only:
+ typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
+
+ position_iterator __position;
+ const value_type* __result;
+ value_type __suffix;
+ std::size_t __n;
+ std::vector<int> __subs;
+ };
+
+ typedef regex_token_iterator<const char*> cregex_token_iterator;
+ typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
+ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+#endif
+
+ /** @} */ // group tr1_regex
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// class template tuple -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/tuple
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+*/
+
+// Chris Jefferson <chris@bubblescope.net>
+// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ template<typename _Tp>
+ class reference_wrapper;
+
+ // Adds a const reference to a non-reference type.
+ template<typename _Tp>
+ struct __add_c_ref
+ { typedef const _Tp& type; };
+
+ template<typename _Tp>
+ struct __add_c_ref<_Tp&>
+ { typedef _Tp& type; };
+
+ // Adds a reference to a non-reference type.
+ template<typename _Tp>
+ struct __add_ref
+ { typedef _Tp& type; };
+
+ template<typename _Tp>
+ struct __add_ref<_Tp&>
+ { typedef _Tp& type; };
+
+ /**
+ * @if maint
+ * Contains the actual implementation of the @c tuple template, stored
+ * as a recursive inheritance hierarchy from the first element (most
+ * derived class) to the last (least derived class). The @c Idx
+ * parameter gives the 0-based index of the element stored at this
+ * point in the hierarchy; we use it to implement a constant-time
+ * get() operation.
+ * @endif
+ */
+ template<int _Idx, typename... _Elements>
+ struct _Tuple_impl;
+
+ /**
+ * @if maint
+ * Zero-element tuple implementation. This is the basis case for the
+ * inheritance recursion.
+ * @endif maint
+ */
+ template<int _Idx>
+ struct _Tuple_impl<_Idx> { };
+
+ /**
+ * @if maint
+ * Recursive tuple implementation. Here we store the @c Head element
+ * and derive from a @c Tuple_impl containing the remaining elements
+ * (which contains the @c Tail).
+ * @endif
+ */
+ template<int _Idx, typename _Head, typename... _Tail>
+ struct _Tuple_impl<_Idx, _Head, _Tail...>
+ : public _Tuple_impl<_Idx + 1, _Tail...>
+ {
+ typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+
+ _Head _M_head;
+
+ _Inherited& _M_tail() { return *this; }
+ const _Inherited& _M_tail() const { return *this; }
+
+ _Tuple_impl() : _Inherited(), _M_head() { }
+
+ explicit
+ _Tuple_impl(typename __add_c_ref<_Head>::type __head,
+ typename __add_c_ref<_Tail>::type... __tail)
+ : _Inherited(__tail...), _M_head(__head) { }
+
+ template<typename... _UElements>
+ _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+ : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+
+ _Tuple_impl(const _Tuple_impl& __in)
+ : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+
+ template<typename... _UElements>
+ _Tuple_impl&
+ operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+ {
+ _M_head = __in._M_head;
+ _M_tail() = __in._M_tail();
+ return *this;
+ }
+
+ _Tuple_impl&
+ operator=(const _Tuple_impl& __in)
+ {
+ _M_head = __in._M_head;
+ _M_tail() = __in._M_tail();
+ return *this;
+ }
+ };
+
+ template<typename... _Elements>
+ class tuple : public _Tuple_impl<0, _Elements...>
+ {
+ typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+ public:
+ tuple() : _Inherited() { }
+
+ explicit
+ tuple(typename __add_c_ref<_Elements>::type... __elements)
+ : _Inherited(__elements...) { }
+
+ template<typename... _UElements>
+ tuple(const tuple<_UElements...>& __in)
+ : _Inherited(__in) { }
+
+ tuple(const tuple& __in)
+ : _Inherited(__in) { }
+
+ template<typename... _UElements>
+ tuple&
+ operator=(const tuple<_UElements...>& __in)
+ {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+ }
+
+ tuple&
+ operator=(const tuple& __in)
+ {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+ }
+ };
+
+ template<> class tuple<> { };
+
+ // 2-element tuple, with construction and assignment from a pair.
+ template<typename _T1, typename _T2>
+ class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+ {
+ typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+ public:
+ tuple() : _Inherited() { }
+
+ explicit
+ tuple(typename __add_c_ref<_T1>::type __a1,
+ typename __add_c_ref<_T2>::type __a2)
+ : _Inherited(__a1, __a2) { }
+
+ template<typename _U1, typename _U2>
+ tuple(const tuple<_U1, _U2>& __in)
+ : _Inherited(__in) { }
+
+ tuple(const tuple& __in)
+ : _Inherited(__in) { }
+
+ template<typename _U1, typename _U2>
+ tuple(const pair<_U1, _U2>& __in)
+ : _Inherited(_Tuple_impl<0,
+ typename __add_c_ref<_U1>::type,
+ typename __add_c_ref<_U2>::type>(__in.first,
+ __in.second))
+ { }
+
+ template<typename _U1, typename _U2>
+ tuple&
+ operator=(const tuple<_U1, _U2>& __in)
+ {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+ }
+
+ tuple&
+ operator=(const tuple& __in)
+ {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+ }
+
+ template<typename _U1, typename _U2>
+ tuple&
+ operator=(const pair<_U1, _U2>& __in)
+ {
+ this->_M_head = __in.first;
+ this->_M_tail()._M_head = __in.second;
+ return *this;
+ }
+ };
+
+
+ /// Gives the type of the ith element of a given tuple type.
+ template<int __i, typename _Tp>
+ struct tuple_element;
+
+ /**
+ * @if maint
+ * Recursive case for tuple_element: strip off the first element in
+ * the tuple and retrieve the (i-1)th element of the remaining tuple.
+ * @endif
+ */
+ template<int __i, typename _Head, typename... _Tail>
+ struct tuple_element<__i, tuple<_Head, _Tail...> >
+ : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+ /**
+ * @if maint
+ * Basis case for tuple_element: The first element is the one we're seeking.
+ * @endif
+ */
+ template<typename _Head, typename... _Tail>
+ struct tuple_element<0, tuple<_Head, _Tail...> >
+ {
+ typedef _Head type;
+ };
+
+ /// Finds the size of a given tuple type.
+ template<typename _Tp>
+ struct tuple_size;
+
+ /// @brief class tuple_size
+ template<typename... _Elements>
+ struct tuple_size<tuple<_Elements...> >
+ {
+ static const int value = sizeof...(_Elements);
+ };
+
+ template<typename... _Elements>
+ const int tuple_size<tuple<_Elements...> >::value;
+
+ template<int __i, typename _Head, typename... _Tail>
+ inline typename __add_ref<_Head>::type
+ __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
+ {
+ return __t._M_head;
+ }
+
+ template<int __i, typename _Head, typename... _Tail>
+ inline typename __add_c_ref<_Head>::type
+ __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
+ {
+ return __t._M_head;
+ }
+
+ // Return a reference (const reference) to the ith element of a tuple.
+ // Any const or non-const ref elements are returned with their original type.
+ template<int __i, typename... _Elements>
+ inline typename __add_ref<
+ typename tuple_element<__i, tuple<_Elements...> >::type
+ >::type
+ get(tuple<_Elements...>& __t)
+ {
+ return __get_helper<__i>(__t);
+ }
+
+ template<int __i, typename... _Elements>
+ inline typename __add_c_ref<
+ typename tuple_element<__i, tuple<_Elements...> >::type
+ >::type
+ get(const tuple<_Elements...>& __t)
+ {
+ return __get_helper<__i>(__t);
+ }
+
+ // This class helps construct the various comparison operations on tuples
+ template<int __check_equal_size, int __i, int __j,
+ typename _Tp, typename _Up>
+ struct __tuple_compare;
+
+ template<int __i, int __j, typename _Tp, typename _Up>
+ struct __tuple_compare<0, __i, __j, _Tp, _Up>
+ {
+ static bool __eq(const _Tp& __t, const _Up& __u)
+ {
+ return (get<__i>(__t) == get<__i>(__u) &&
+ __tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
+ }
+
+ static bool __less(const _Tp& __t, const _Up& __u)
+ {
+ return ((get<__i>(__t) < get<__i>(__u))
+ || !(get<__i>(__u) < get<__i>(__t)) &&
+ __tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
+ }
+ };
+
+ template<int __i, typename _Tp, typename _Up>
+ struct __tuple_compare<0, __i, __i, _Tp, _Up>
+ {
+ static bool __eq(const _Tp&, const _Up&)
+ { return true; }
+
+ static bool __less(const _Tp&, const _Up&)
+ { return false; }
+ };
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator==(const tuple<_TElements...>& __t,
+ const tuple<_UElements...>& __u)
+ {
+ typedef tuple<_TElements...> _Tp;
+ typedef tuple<_UElements...> _Up;
+ return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
+ 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
+ }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator<(const tuple<_TElements...>& __t,
+ const tuple<_UElements...>& __u)
+ {
+ typedef tuple<_TElements...> _Tp;
+ typedef tuple<_UElements...> _Up;
+ return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value,
+ 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
+ }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator!=(const tuple<_TElements...>& __t,
+ const tuple<_UElements...>& __u)
+ { return !(__t == __u); }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator>(const tuple<_TElements...>& __t,
+ const tuple<_UElements...>& __u)
+ { return __u < __t; }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator<=(const tuple<_TElements...>& __t,
+ const tuple<_UElements...>& __u)
+ { return !(__u < __t); }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator>=(const tuple<_TElements...>& __t,
+ const tuple<_UElements...>& __u)
+ { return !(__t < __u); }
+
+ // Helper which adds a reference to a type when given a reference_wrapper
+ template<typename _Tp>
+ struct __strip_reference_wrapper
+ {
+ typedef _Tp __type;
+ };
+
+ template<typename _Tp>
+ struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+ {
+ typedef _Tp& __type;
+ };
+
+ template<typename _Tp>
+ struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
+ {
+ typedef _Tp& __type;
+ };
+
+ template<typename... _Elements>
+ inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+ make_tuple(_Elements... __args)
+ {
+ typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+ __result_type;
+ return __result_type(__args...);
+ }
+
+ template<typename... _Elements>
+ inline tuple<_Elements&...>
+ tie(_Elements&... __args)
+ {
+ return tuple<_Elements&...>(__args...);
+ }
+
+ // A class (and instance) which can be used in 'tie' when an element
+ // of a tuple is not required
+ struct _Swallow_assign
+ {
+ template<class _Tp>
+ _Swallow_assign&
+ operator=(const _Tp&)
+ { return *this; }
+ };
+
+ // TODO: Put this in some kind of shared file.
+ namespace
+ {
+ _Swallow_assign ignore;
+ }; // anonymous namespace
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// TR1 type_traits -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/type_traits
+* This is an internal header file, included by other library headers.
+* You should not attempt to use it directly.
+*/
+
+#include <tr1_impl/type_traitsfwd.h>
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // For use in __is_convertible_simple.
+ struct __sfinae_types
+ {
+ typedef char __one;
+ typedef struct { char __arr[2]; } __two;
+ };
+
+#define _DEFINE_SPEC_BODY(_Value) \
+ : public integral_constant<bool, _Value> { };
+
+#define _DEFINE_SPEC_0_HELPER(_Spec, _Value) \
+ template<> \
+ struct _Spec \
+ _DEFINE_SPEC_BODY(_Value)
+
+#define _DEFINE_SPEC_1_HELPER(_Spec, _Value) \
+ template<typename _Tp> \
+ struct _Spec \
+ _DEFINE_SPEC_BODY(_Value)
+
+#define _DEFINE_SPEC_2_HELPER(_Spec, _Value) \
+ template<typename _Tp, typename _Cp> \
+ struct _Spec \
+ _DEFINE_SPEC_BODY(_Value)
+
+#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value) \
+ _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type>, _Value) \
+ _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const>, _Value) \
+ _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type volatile>, _Value) \
+ _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const volatile>, _Value)
+
+ /// @brief helper classes [4.3].
+ template<typename _Tp, _Tp __v>
+ struct integral_constant
+ {
+ static const _Tp value = __v;
+ typedef _Tp value_type;
+ typedef integral_constant<_Tp, __v> type;
+ };
+ typedef integral_constant<bool, true> true_type;
+ typedef integral_constant<bool, false> false_type;
+
+ template<typename _Tp, _Tp __v>
+ const _Tp integral_constant<_Tp, __v>::value;
+
+ /// @brief primary type categories [4.5.1].
+ template<typename>
+ struct is_void
+ : public false_type { };
+ _DEFINE_SPEC(0, is_void, void, true)
+
+ template<typename>
+ struct is_integral
+ : public false_type { };
+ _DEFINE_SPEC(0, is_integral, bool, true)
+ _DEFINE_SPEC(0, is_integral, char, true)
+ _DEFINE_SPEC(0, is_integral, signed char, true)
+ _DEFINE_SPEC(0, is_integral, unsigned char, true)
+#ifdef _GLIBCXX_USE_WCHAR_T
+ _DEFINE_SPEC(0, is_integral, wchar_t, true)
+#endif
+ _DEFINE_SPEC(0, is_integral, short, true)
+ _DEFINE_SPEC(0, is_integral, unsigned short, true)
+ _DEFINE_SPEC(0, is_integral, int, true)
+ _DEFINE_SPEC(0, is_integral, unsigned int, true)
+ _DEFINE_SPEC(0, is_integral, long, true)
+ _DEFINE_SPEC(0, is_integral, unsigned long, true)
+ _DEFINE_SPEC(0, is_integral, long long, true)
+ _DEFINE_SPEC(0, is_integral, unsigned long long, true)
+
+ template<typename>
+ struct is_floating_point
+ : public false_type { };
+ _DEFINE_SPEC(0, is_floating_point, float, true)
+ _DEFINE_SPEC(0, is_floating_point, double, true)
+ _DEFINE_SPEC(0, is_floating_point, long double, true)
+
+ template<typename>
+ struct is_array
+ : public false_type { };
+
+ template<typename _Tp, std::size_t _Size>
+ struct is_array<_Tp[_Size]>
+ : public true_type { };
+
+ template<typename _Tp>
+ struct is_array<_Tp[]>
+ : public true_type { };
+
+ template<typename>
+ struct is_pointer
+ : public false_type { };
+ _DEFINE_SPEC(1, is_pointer, _Tp*, true)
+
+ template<typename>
+ struct is_reference
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_reference<_Tp&>
+ : public true_type { };
+
+ template<typename>
+ struct is_member_object_pointer
+ : public false_type { };
+ _DEFINE_SPEC(2, is_member_object_pointer, _Tp _Cp::*,
+ !is_function<_Tp>::value)
+
+ template<typename>
+ struct is_member_function_pointer
+ : public false_type { };
+ _DEFINE_SPEC(2, is_member_function_pointer, _Tp _Cp::*,
+ is_function<_Tp>::value)
+
+ template<typename _Tp>
+ struct is_enum
+ : public integral_constant<bool, __is_enum(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct is_union
+ : public integral_constant<bool, __is_union(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct is_class
+ : public integral_constant<bool, __is_class(_Tp)>
+ { };
+
+ template<typename>
+ struct __is_function_helper
+ : public false_type { };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct __is_function_helper<_Res(_ArgTypes...)>
+ : public true_type { };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct __is_function_helper<_Res(_ArgTypes......)>
+ : public true_type { };
+
+ template<typename _Tp>
+ struct is_function
+ : public integral_constant<bool, (__is_function_helper<typename
+ remove_cv<_Tp>::type>::value)>
+ { };
+
+ /// @brief composite type traits [4.5.2].
+ template<typename _Tp>
+ struct is_arithmetic
+ : public integral_constant<bool, (is_integral<_Tp>::value
+ || is_floating_point<_Tp>::value)>
+ { };
+
+ template<typename _Tp>
+ struct is_fundamental
+ : public integral_constant<bool, (is_arithmetic<_Tp>::value
+ || is_void<_Tp>::value)>
+ { };
+
+ template<typename _Tp>
+ struct is_object
+ : public integral_constant<bool, !(is_function<_Tp>::value
+ || is_reference<_Tp>::value
+ || is_void<_Tp>::value)>
+ { };
+
+ template<typename _Tp>
+ struct is_scalar
+ : public integral_constant<bool, (is_arithmetic<_Tp>::value
+ || is_enum<_Tp>::value
+ || is_pointer<_Tp>::value
+ || is_member_pointer<_Tp>::value)>
+ { };
+
+ template<typename _Tp>
+ struct is_compound
+ : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
+
+ template<typename _Tp>
+ struct is_member_pointer
+ : public integral_constant<bool,
+ (is_member_object_pointer<_Tp>::value
+ || is_member_function_pointer<_Tp>::value)>
+ { };
+
+ /// @brief type properties [4.5.3].
+ template<typename>
+ struct is_const
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_const<_Tp const>
+ : public true_type { };
+
+ template<typename>
+ struct is_volatile
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_volatile<_Tp volatile>
+ : public true_type { };
+
+ template<typename _Tp>
+ struct is_empty
+ : public integral_constant<bool, __is_empty(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct is_polymorphic
+ : public integral_constant<bool, __is_polymorphic(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct is_abstract
+ : public integral_constant<bool, __is_abstract(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct has_virtual_destructor
+ : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+ { };
+
+ template<typename _Tp>
+ struct alignment_of
+ : public integral_constant<std::size_t, __alignof__(_Tp)> { };
+
+ template<typename>
+ struct rank
+ : public integral_constant<std::size_t, 0> { };
+
+ template<typename _Tp, std::size_t _Size>
+ struct rank<_Tp[_Size]>
+ : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+ template<typename _Tp>
+ struct rank<_Tp[]>
+ : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+ template<typename, unsigned>
+ struct extent
+ : public integral_constant<std::size_t, 0> { };
+
+ template<typename _Tp, unsigned _Uint, std::size_t _Size>
+ struct extent<_Tp[_Size], _Uint>
+ : public integral_constant<std::size_t,
+ _Uint == 0 ? _Size : extent<_Tp,
+ _Uint - 1>::value>
+ { };
+
+ template<typename _Tp, unsigned _Uint>
+ struct extent<_Tp[], _Uint>
+ : public integral_constant<std::size_t,
+ _Uint == 0 ? 0 : extent<_Tp,
+ _Uint - 1>::value>
+ { };
+
+ /// @brief relationships between types [4.6].
+ template<typename, typename>
+ struct is_same
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_same<_Tp, _Tp>
+ : public true_type { };
+
+ /// @brief const-volatile modifications [4.7.1].
+ template<typename _Tp>
+ struct remove_const
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_const<_Tp const>
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_volatile
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_volatile<_Tp volatile>
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_cv
+ {
+ typedef typename
+ remove_const<typename remove_volatile<_Tp>::type>::type type;
+ };
+
+ template<typename _Tp>
+ struct add_const
+ { typedef _Tp const type; };
+
+ template<typename _Tp>
+ struct add_volatile
+ { typedef _Tp volatile type; };
+
+ template<typename _Tp>
+ struct add_cv
+ {
+ typedef typename
+ add_const<typename add_volatile<_Tp>::type>::type type;
+ };
+
+ /// @brief reference modifications [4.7.2].
+ template<typename _Tp>
+ struct remove_reference
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_reference<_Tp&>
+ { typedef _Tp type; };
+
+ // NB: Careful with reference to void.
+ template<typename _Tp, bool = (is_void<_Tp>::value
+ || is_reference<_Tp>::value)>
+ struct __add_reference_helper
+ { typedef _Tp& type; };
+
+ template<typename _Tp>
+ struct __add_reference_helper<_Tp, true>
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct add_reference
+ : public __add_reference_helper<_Tp>
+ { };
+
+ /// @brief array modifications [4.7.3].
+ template<typename _Tp>
+ struct remove_extent
+ { typedef _Tp type; };
+
+ template<typename _Tp, std::size_t _Size>
+ struct remove_extent<_Tp[_Size]>
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_extent<_Tp[]>
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_all_extents
+ { typedef _Tp type; };
+
+ template<typename _Tp, std::size_t _Size>
+ struct remove_all_extents<_Tp[_Size]>
+ { typedef typename remove_all_extents<_Tp>::type type; };
+
+ template<typename _Tp>
+ struct remove_all_extents<_Tp[]>
+ { typedef typename remove_all_extents<_Tp>::type type; };
+
+ /// @brief pointer modifications [4.7.4].
+#undef _DEFINE_SPEC_BODY
+#define _DEFINE_SPEC_BODY(_Value) \
+ { typedef _Tp type; };
+
+ template<typename _Tp>
+ struct remove_pointer
+ { typedef _Tp type; };
+ _DEFINE_SPEC(1, remove_pointer, _Tp*, false)
+
+ template<typename _Tp>
+ struct add_pointer
+ { typedef typename remove_reference<_Tp>::type* type; };
+
+ /// @brief other transformations [4.8].
+
+ // Due to c++/19163 and c++/17743, for the time being we cannot use
+ // the correct, neat implementation :-(
+ //
+ // template<std::size_t _Len, std::size_t _Align>
+ // struct aligned_storage
+ // { typedef char type[_Len] __attribute__((__aligned__(_Align))); }
+ //
+ // Temporary workaround, useful for Align up to 32:
+ template<std::size_t, std::size_t>
+ struct aligned_storage { };
+
+ template<std::size_t _Len>
+ struct aligned_storage<_Len, 1>
+ {
+ union type
+ {
+ unsigned char __data[_Len];
+ char __align __attribute__((__aligned__(1)));
+ };
+ };
+
+ template<std::size_t _Len>
+ struct aligned_storage<_Len, 2>
+ {
+ union type
+ {
+ unsigned char __data[_Len];
+ char __align __attribute__((__aligned__(2)));
+ };
+ };
+
+ template<std::size_t _Len>
+ struct aligned_storage<_Len, 4>
+ {
+ union type
+ {
+ unsigned char __data[_Len];
+ char __align __attribute__((__aligned__(4)));
+ };
+ };
+
+ template<std::size_t _Len>
+ struct aligned_storage<_Len, 8>
+ {
+ union type
+ {
+ unsigned char __data[_Len];
+ char __align __attribute__((__aligned__(8)));
+ };
+ };
+
+ template<std::size_t _Len>
+ struct aligned_storage<_Len, 16>
+ {
+ union type
+ {
+ unsigned char __data[_Len];
+ char __align __attribute__((__aligned__(16)));
+ };
+ };
+
+ template<std::size_t _Len>
+ struct aligned_storage<_Len, 32>
+ {
+ union type
+ {
+ unsigned char __data[_Len];
+ char __align __attribute__((__aligned__(32)));
+ };
+ };
+
+#undef _DEFINE_SPEC_0_HELPER
+#undef _DEFINE_SPEC_1_HELPER
+#undef _DEFINE_SPEC_2_HELPER
+#undef _DEFINE_SPEC
+#undef _DEFINE_SPEC_BODY
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
-// TR1 type_traits -*- C++ -*-
+// TR1 type_traitsfwd.h -*- C++ -*-
-// Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
-/** @file tr1/type_traitsfwd.h
+/** @file tr1_impl/type_traitsfwd.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
-#ifndef _TYPE_TRAITSFWD_H
-#define _TYPE_TRAITSFWD_H 1
-
-#include <cstddef>
-
-// namespace std::tr1
namespace std
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
+_GLIBCXX_BEGIN_NAMESPACE_TR1
/// @brief helper classes [4.3].
template<typename _Tp, _Tp __v>
template<typename _Tp>
struct is_volatile;
- template<typename _Tp>
- struct is_pod;
-
template<typename _Tp>
struct is_empty;
template<typename _Tp>
struct is_abstract;
- template<typename _Tp>
- struct has_trivial_constructor;
-
- template<typename _Tp>
- struct has_trivial_copy;
-
- template<typename _Tp>
- struct has_trivial_assign;
-
- template<typename _Tp>
- struct has_trivial_destructor;
-
- template<typename _Tp>
- struct has_nothrow_constructor;
-
- template<typename _Tp>
- struct has_nothrow_copy;
-
- template<typename _Tp>
- struct has_nothrow_assign;
-
template<typename _Tp>
struct has_virtual_destructor;
- template<typename _Tp>
- struct is_signed;
-
- template<typename _Tp>
- struct is_unsigned;
-
template<typename _Tp>
struct alignment_of;
template<typename _Tp, typename _Up>
struct is_same;
- template<typename _From, typename _To>
- struct is_convertible;
-
- template<typename _Base, typename _Derived>
- struct is_base_of;
-
/// @brief const-volatile modifications [4.7.1].
template<typename _Tp>
struct remove_const;
template<std::size_t _Len, std::size_t _Align>
struct aligned_storage;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_TR1
}
-
-#endif
--- /dev/null
+// TR1 unordered_map -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/unordered_map
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // XXX When we get typedef templates these class definitions
+ // will be unnecessary.
+ template<class _Key, class _Tp,
+ class _Hash = hash<_Key>,
+ class _Pred = std::equal_to<_Key>,
+ class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+ bool __cache_hash_code = false>
+ class __unordered_map
+ : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
+ std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, false, true>
+ {
+ typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
+ std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, false, true>
+ _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ __unordered_map(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(),
+ __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+ { }
+
+ template<typename _InputIterator>
+ __unordered_map(_InputIterator __f, _InputIterator __l,
+ size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(),
+ __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+ { }
+ };
+
+ template<class _Key, class _Tp,
+ class _Hash = hash<_Key>,
+ class _Pred = std::equal_to<_Key>,
+ class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+ bool __cache_hash_code = false>
+ class __unordered_multimap
+ : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
+ _Alloc,
+ std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, false, false>
+ {
+ typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
+ _Alloc,
+ std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, false, false>
+ _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ __unordered_multimap(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(),
+ __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+ { }
+
+
+ template<typename _InputIterator>
+ __unordered_multimap(_InputIterator __f, _InputIterator __l,
+ typename _Base::size_type __n = 0,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(),
+ __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+ { }
+ };
+
+ template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+ bool __cache_hash_code>
+ inline void
+ swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __x,
+ __unordered_map<_Key, _Tp, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __y)
+ { __x.swap(__y); }
+
+ template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+ bool __cache_hash_code>
+ inline void
+ swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __x,
+ __unordered_multimap<_Key, _Tp, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __y)
+ { __x.swap(__y); }
+
+
+ template<class _Key, class _Tp,
+ class _Hash = hash<_Key>,
+ class _Pred = std::equal_to<_Key>,
+ class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+ class unordered_map
+ : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
+ {
+ typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ unordered_map(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __eql, __a)
+ { }
+
+ template<typename _InputIterator>
+ unordered_map(_InputIterator __f, _InputIterator __l,
+ size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __eql, __a)
+ { }
+ };
+
+ template<class _Key, class _Tp,
+ class _Hash = hash<_Key>,
+ class _Pred = std::equal_to<_Key>,
+ class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+ class unordered_multimap
+ : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
+ {
+ typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ unordered_multimap(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __eql, __a)
+ { }
+
+
+ template<typename _InputIterator>
+ unordered_multimap(_InputIterator __f, _InputIterator __l,
+ typename _Base::size_type __n = 0,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __eql, __a)
+ { }
+ };
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+// TR1 unordered_set -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/unordered_set
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ // XXX When we get typedef templates these class definitions
+ // will be unnecessary.
+ template<class _Value,
+ class _Hash = hash<_Value>,
+ class _Pred = std::equal_to<_Value>,
+ class _Alloc = std::allocator<_Value>,
+ bool __cache_hash_code = false>
+ class __unordered_set
+ : public _Hashtable<_Value, _Value, _Alloc,
+ std::_Identity<_Value>, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, true, true>
+ {
+ typedef _Hashtable<_Value, _Value, _Alloc,
+ std::_Identity<_Value>, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, true, true>
+ _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ __unordered_set(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(), __eql,
+ std::_Identity<_Value>(), __a)
+ { }
+
+ template<typename _InputIterator>
+ __unordered_set(_InputIterator __f, _InputIterator __l,
+ size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(), __eql,
+ std::_Identity<_Value>(), __a)
+ { }
+ };
+
+ template<class _Value,
+ class _Hash = hash<_Value>,
+ class _Pred = std::equal_to<_Value>,
+ class _Alloc = std::allocator<_Value>,
+ bool __cache_hash_code = false>
+ class __unordered_multiset
+ : public _Hashtable<_Value, _Value, _Alloc,
+ std::_Identity<_Value>, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, true, false>
+ {
+ typedef _Hashtable<_Value, _Value, _Alloc,
+ std::_Identity<_Value>, _Pred,
+ _Hash, __detail::_Mod_range_hashing,
+ __detail::_Default_ranged_hash,
+ __detail::_Prime_rehash_policy,
+ __cache_hash_code, true, false>
+ _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ __unordered_multiset(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(), __eql,
+ std::_Identity<_Value>(), __a)
+ { }
+
+
+ template<typename _InputIterator>
+ __unordered_multiset(_InputIterator __f, _InputIterator __l,
+ typename _Base::size_type __n = 0,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+ __detail::_Default_ranged_hash(), __eql,
+ std::_Identity<_Value>(), __a)
+ { }
+ };
+
+ template<class _Value, class _Hash, class _Pred, class _Alloc,
+ bool __cache_hash_code>
+ inline void
+ swap (__unordered_set<_Value, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __x,
+ __unordered_set<_Value, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __y)
+ { __x.swap(__y); }
+
+ template<class _Value, class _Hash, class _Pred, class _Alloc,
+ bool __cache_hash_code>
+ inline void
+ swap(__unordered_multiset<_Value, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __x,
+ __unordered_multiset<_Value, _Hash, _Pred,
+ _Alloc, __cache_hash_code>& __y)
+ { __x.swap(__y); }
+
+
+ template<class _Value,
+ class _Hash = hash<_Value>,
+ class _Pred = std::equal_to<_Value>,
+ class _Alloc = std::allocator<_Value> >
+ class unordered_set
+ : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
+ {
+ typedef __unordered_set<_Value, _Hash, _Pred, _Alloc> _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ unordered_set(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __eql, __a)
+ { }
+
+ template<typename _InputIterator>
+ unordered_set(_InputIterator __f, _InputIterator __l,
+ size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __eql, __a)
+ { }
+ };
+
+ template<class _Value,
+ class _Hash = hash<_Value>,
+ class _Pred = std::equal_to<_Value>,
+ class _Alloc = std::allocator<_Value> >
+ class unordered_multiset
+ : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
+ {
+ typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc> _Base;
+
+ public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+
+ explicit
+ unordered_multiset(size_type __n = 10,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__n, __hf, __eql, __a)
+ { }
+
+
+ template<typename _InputIterator>
+ unordered_multiset(_InputIterator __f, _InputIterator __l,
+ typename _Base::size_type __n = 0,
+ const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _Base(__f, __l, __n, __hf, __eql, __a)
+ { }
+ };
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
--- /dev/null
+
+// TR1 utility -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1_impl/utility
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_TR1
+
+ template<class _Tp> class tuple_size;
+ template<int _Int, class _Tp> class tuple_element;
+
+ // Various functions which give std::pair a tuple-like interface.
+ template<class _Tp1, class _Tp2>
+ struct tuple_size<std::pair<_Tp1, _Tp2> >
+ { static const int value = 2; };
+
+ template<class _Tp1, class _Tp2>
+ const int tuple_size<std::pair<_Tp1, _Tp2> >::value;
+
+ template<class _Tp1, class _Tp2>
+ struct tuple_element<0, std::pair<_Tp1, _Tp2> >
+ { typedef _Tp1 type; };
+
+ template<class _Tp1, class _Tp2>
+ struct tuple_element<1, std::pair<_Tp1, _Tp2> >
+ { typedef _Tp2 type; };
+
+
+ template<int _Int> struct __pair_get;
+
+ template<>
+ struct __pair_get<0>
+ {
+ template<typename _Tp1, typename _Tp2>
+ static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair)
+ { return __pair.first; }
+
+ template<typename _Tp1, typename _Tp2>
+ static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
+ { return __pair.first; }
+ };
+
+ template<>
+ struct __pair_get<1>
+ {
+ template<typename _Tp1, typename _Tp2>
+ static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair)
+ { return __pair.second; }
+
+ template<typename _Tp1, typename _Tp2>
+ static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
+ { return __pair.second; }
+ };
+
+ template<int _Int, class _Tp1, class _Tp2>
+ inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
+ get(std::pair<_Tp1, _Tp2>& __in)
+ { return __pair_get<_Int>::__get(__in); }
+
+ template<int _Int, class _Tp1, class _Tp2>
+ inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
+ get(const std::pair<_Tp1, _Tp2>& __in)
+ { return __pair_get<_Int>::__const_get(__in); }
+
+_GLIBCXX_END_NAMESPACE_TR1
+}
+
using std::has_nothrow_copy_constructor;
using namespace __gnu_test;
- VERIFY( (test_category<has_nothrow_copy_constructor, void>(true)) );
+ // Positive tests.
VERIFY( (test_category<has_nothrow_copy_constructor, int>(true)) );
VERIFY( (test_category<has_nothrow_copy_constructor, float>(true)) );
VERIFY( (test_category<has_nothrow_copy_constructor, EnumType>(true)) );
VERIFY( (test_category<has_nothrow_copy_constructor, int (ClassType::*[2][3])>(true)) );
VERIFY( (test_category<has_nothrow_copy_constructor,
int (ClassType::*[][2][3]) (int)>(true)) );
+
+ // Negative tests.
+ VERIFY( (test_category<has_nothrow_copy_constructor, void>(false)) );
}
int main()
using std::has_nothrow_default_constructor;
using namespace __gnu_test;
- VERIFY( (test_category<has_nothrow_default_constructor, void>(true)) );
+ // Positive tests.
VERIFY( (test_category<has_nothrow_default_constructor, int>(true)) );
VERIFY( (test_category<has_nothrow_default_constructor, float>(true)) );
VERIFY( (test_category<has_nothrow_default_constructor, EnumType>(true)) );
VERIFY( (test_category<has_nothrow_default_constructor,
int (ClassType::*[][2][3]) (int)>(true)) );
VERIFY( (test_category<has_nothrow_default_constructor, ClassType>(true)) );
+
+ // Negative tests.
+ VERIFY( (test_category<has_nothrow_default_constructor, void>(false)) );
}
int main()
using std::has_trivial_copy_constructor;
using namespace __gnu_test;
- VERIFY( (test_category<has_trivial_copy_constructor, void>(true)) );
+ // Positive tests.
VERIFY( (test_category<has_trivial_copy_constructor, int>(true)) );
VERIFY( (test_category<has_trivial_copy_constructor, float>(true)) );
VERIFY( (test_category<has_trivial_copy_constructor, EnumType>(true)) );
VERIFY( (test_category<has_trivial_copy_constructor, int (ClassType::*[2][3])>(true)) );
VERIFY( (test_category<has_trivial_copy_constructor,
int (ClassType::*[][2][3]) (int)>(true)) );
+
+ // Negative tests.
+ VERIFY( (test_category<has_trivial_copy_constructor, void>(false)) );
}
int main()
using std::has_trivial_default_constructor;
using namespace __gnu_test;
- VERIFY( (test_category<has_trivial_default_constructor, void>(true)) );
+ // Positive tests.
VERIFY( (test_category<has_trivial_default_constructor, int>(true)) );
VERIFY( (test_category<has_trivial_default_constructor, float>(true)) );
VERIFY( (test_category<has_trivial_default_constructor, EnumType>(true)) );
VERIFY( (test_category<has_trivial_default_constructor,
int (ClassType::*[][2][3]) (int)>(true)) );
VERIFY( (test_category<has_trivial_default_constructor, ClassType>(true)) );
+
+ // Negative tests.
+ VERIFY( (test_category<has_trivial_default_constructor, void>(false)) );
}
int main()
using std::has_nothrow_copy;
}
-// { dg-error "has not been declared" "" { xfail *-*-* } 27 }
-// { dg-error "has not been declared" "" { xfail *-*-* } 28 }
-// { dg-error "has not been declared" "" { xfail *-*-* } 29 }
-// { dg-error "has not been declared" "" { xfail *-*-* } 30 }
+// { dg-error "has not been declared" "" { target *-*-* } 27 }
+// { dg-error "has not been declared" "" { target *-*-* } 28 }
+// { dg-error "has not been declared" "" { target *-*-* } 29 }
+// { dg-error "has not been declared" "" { target *-*-* } 30 }
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+// 2007-04-30 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+namespace std
+{
+ typedef short test_type;
+ template struct is_signed<test_type>;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24 Paolo Carlini <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+//
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+// { dg-do compile }
+
+void test01()
+{
+ // Check for required typedefs
+ typedef std::is_signed<int> test_type;
+ typedef test_type::value_type value_type;
+ typedef test_type::type type;
+ typedef test_type::type::value_type type_value_type;
+ typedef test_type::type::type type_type;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24 Paolo Carlini <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+#include <type_traits>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ using std::is_signed;
+ using namespace __gnu_test;
+
+ VERIFY( (test_category<is_signed, void>(false)) );
+
+ VERIFY( (test_category<is_signed, char>(char(-1) < char(0))) );
+ VERIFY( (test_category<is_signed, signed char>(true)) );
+ VERIFY( (test_category<is_signed, unsigned char>(false)) );
+#ifdef _GLIBCXX_USE_WCHAR_T
+ VERIFY( (test_category<is_signed, wchar_t>(wchar_t(-1) < wchar_t(0))) );
+#endif
+ VERIFY( (test_category<is_signed, short>(true)) );
+ VERIFY( (test_category<is_signed, unsigned short>(false)) );
+ VERIFY( (test_category<is_signed, int>(true)) );
+ VERIFY( (test_category<is_signed, unsigned int>(false)) );
+ VERIFY( (test_category<is_signed, long>(true)) );
+ VERIFY( (test_category<is_signed, unsigned long>(false)) );
+ VERIFY( (test_category<is_signed, long long>(true)) );
+ VERIFY( (test_category<is_signed, unsigned long long>(false)) );
+
+ VERIFY( (test_category<is_signed, float>(true)) );
+ VERIFY( (test_category<is_signed, double>(true)) );
+ VERIFY( (test_category<is_signed, long double>(true)) );
+
+ // Sanity check.
+ VERIFY( (test_category<is_signed, ClassType>(false)) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+// 2007-04-30 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+namespace std
+{
+ typedef short test_type;
+ template struct is_unsigned<test_type>;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24 Paolo Carlini <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+//
+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
+
+#include <type_traits>
+
+// { dg-do compile }
+
+void test01()
+{
+ // Check for required typedefs
+ typedef std::is_unsigned<int> test_type;
+ typedef test_type::value_type value_type;
+ typedef test_type::type type;
+ typedef test_type::type::value_type type_value_type;
+ typedef test_type::type::type type_type;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// 2005-01-24 Paolo Carlini <pcarlini@suse.de>
+//
+// Copyright (C) 2005 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+#include <type_traits>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ using std::is_unsigned;
+ using namespace __gnu_test;
+
+ VERIFY( (test_category<is_unsigned, void>(false)) );
+
+ VERIFY( (test_category<is_unsigned, char>(char(-1) > char(0))) );
+ VERIFY( (test_category<is_unsigned, signed char>(false)) );
+ VERIFY( (test_category<is_unsigned, unsigned char>(true)) );
+#ifdef _GLIBCXX_USE_WCHAR_T
+ VERIFY( (test_category<is_unsigned, wchar_t>(wchar_t(-1) > wchar_t(0))) );
+#endif
+ VERIFY( (test_category<is_unsigned, short>(false)) );
+ VERIFY( (test_category<is_unsigned, unsigned short>(true)) );
+ VERIFY( (test_category<is_unsigned, int>(false)) );
+ VERIFY( (test_category<is_unsigned, unsigned int>(true)) );
+ VERIFY( (test_category<is_unsigned, long>(false)) );
+ VERIFY( (test_category<is_unsigned, unsigned long>(true)) );
+ VERIFY( (test_category<is_unsigned, long long>(false)) );
+ VERIFY( (test_category<is_unsigned, unsigned long long>(true)) );
+
+ VERIFY( (test_category<is_unsigned, float>(false)) );
+ VERIFY( (test_category<is_unsigned, double>(false)) );
+ VERIFY( (test_category<is_unsigned, long double>(false)) );
+
+ // Sanity check.
+ VERIFY( (test_category<is_unsigned, ClassType>(false)) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
// { dg-error "instantiated from here" "" { target *-*-* } 41 }
// { dg-error "instantiated from here" "" { target *-*-* } 43 }
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 291 }
-// { dg-error "declaration of" "" { target *-*-* } 253 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 424 }
+// { dg-error "declaration of" "" { target *-*-* } 390 }
// { dg-excess-errors "At global scope" }
// { dg-excess-errors "In instantiation of" }
// { dg-error "instantiated from here" "" { target *-*-* } 41 }
// { dg-error "instantiated from here" "" { target *-*-* } 43 }
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 208 }
-// { dg-error "declaration of" "" { target *-*-* } 170 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 345 }
+// { dg-error "declaration of" "" { target *-*-* } 311 }
// { dg-excess-errors "At global scope" }
// { dg-excess-errors "In instantiation of" }
#include <tr1/tuple>
-template class std::tuple<short, int, double>;
+template class std::tr1::tuple<short, int, double>;
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+#include <tr1/tuple>
+
+namespace gnu
+{
+ using namespace std::tr1;
+}
projects / thirdparty / gcc.git / commitdiff
